PHP's base64_encode in TypeScript

How to use

Install via yarn add locutus and import: import { base64_encode } from 'locutus/php/url/base64_encode'.

Or with CommonJS: const { base64_encode } = require('locutus/php/url/base64_encode')

Use a bundler that supports tree-shaking so you only ship the functions you actually use. Vite, webpack, Rollup, and Parcel all handle this. For server-side use this is less of a concern.

Examples

These examples are extracted from test cases that automatically verify our functions against their native counterparts.

#	code	expected result
1	base64_encode('Kevin van Zonneveld')	'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
2	base64_encode('a')	'YQ=='
3	base64_encode('✓ à la mode')	'4pyTIMOgIGxhIG1vZGU='

Dependencies

This function uses the following Locutus functions:

• _phpRuntimeState (php/_helpers)
• _phpTypes (php/_helpers)

Here's what our current TypeScript equivalent to PHP's base64_encode looks like.

TSTypeScript JSJavaScript TSStandalone TS JSStandalone JS

Copy code

import { getPhpGlobalCallable, getPhpGlobalEntry, getPhpObjectEntry } from '../_helpers/_phpRuntimeState.ts'
import { isObjectLike, isPhpCallable } from '../_helpers/_phpTypes.ts'

export function base64_encode(stringToEncode: string | null | undefined): string | null | undefined {
  //      discuss at: https://locutus.io/php/base64_encode/
  // parity verified: PHP 8.3
  //     original by: Tyler Akins (https://rumkin.com)
  //     improved by: Bayron Guevara
  //     improved by: Thunder.m
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Rafał Kukawski (https://blog.kukawski.pl)
  //     bugfixed by: Pellentesque Malesuada
  //     improved by: Indigo744
  //       example 1: base64_encode('Kevin van Zonneveld')
  //       returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
  //       example 2: base64_encode('a')
  //       returns 2: 'YQ=='
  //       example 3: base64_encode('✓ à la mode')
  //       returns 3: '4pyTIMOgIGxhIG1vZGU='

  // encodeUTF8string()
  // Internal function to encode properly UTF8 string
  // Adapted from Solution #1 at https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
  const encodeUTF8string = function (str: string): string {
    // first we use encodeURIComponent to get percent-encoded UTF-8,
    // then we convert the percent encodings into raw bytes which
    // can be fed into the base64 encoding algorithm.
    return encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function toSolidBytes(_match, p1: string) {
      return String.fromCharCode(Number.parseInt(p1, 16))
    })
  }

  const bufferValue = getPhpGlobalEntry('Buffer')
  if (isObjectLike(bufferValue)) {
    const bufferFrom = getPhpObjectEntry(bufferValue, 'from')
    if (isPhpCallable<[string], object>(bufferFrom)) {
      const encoded = bufferFrom.call(bufferValue, String(stringToEncode))
      if (typeof encoded === 'object' && encoded !== null) {
        const encodedToString = getPhpObjectEntry(encoded, 'toString')
        if (isPhpCallable<[string], string>(encodedToString)) {
          const base64Value = encodedToString.call(encoded, 'base64')
          if (typeof base64Value === 'string') {
            return base64Value
          }
        }
      }
    }
  }

  const btoaValue = getPhpGlobalCallable<[string], string>('btoa')
  if (btoaValue) {
    const encoded = btoaValue(encodeUTF8string(String(stringToEncode)))
    if (typeof encoded === 'string') {
      return encoded
    }
  }

  const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  let o1: number
  let o2: number
  let o3: number
  let h1: number
  let h2: number
  let h3: number
  let h4: number
  let bits: number
  let i = 0
  let ac = 0
  let enc = ''
  const tmpArr: string[] = []

  if (!stringToEncode) {
    return stringToEncode
  }

  stringToEncode = encodeUTF8string(stringToEncode)

  do {
    // pack three octets into four hexets
    o1 = stringToEncode.charCodeAt(i++)
    o2 = stringToEncode.charCodeAt(i++)
    o3 = stringToEncode.charCodeAt(i++)

    bits = (o1 << 16) | (o2 << 8) | o3

    h1 = (bits >> 18) & 0x3f
    h2 = (bits >> 12) & 0x3f
    h3 = (bits >> 6) & 0x3f
    h4 = bits & 0x3f

    // use hexets to index into b64, and append result to encoded string
    tmpArr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4)
  } while (i < stringToEncode.length)

  enc = tmpArr.join('')

  const r = stringToEncode.length % 3

  return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3)
}

import { getPhpGlobalCallable, getPhpGlobalEntry, getPhpObjectEntry } from '../_helpers/_phpRuntimeState.ts'
import { isObjectLike, isPhpCallable } from '../_helpers/_phpTypes.ts'

export function base64_encode(stringToEncode) {
  //      discuss at: https://locutus.io/php/base64_encode/
  // parity verified: PHP 8.3
  //     original by: Tyler Akins (https://rumkin.com)
  //     improved by: Bayron Guevara
  //     improved by: Thunder.m
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Rafał Kukawski (https://blog.kukawski.pl)
  //     bugfixed by: Pellentesque Malesuada
  //     improved by: Indigo744
  //       example 1: base64_encode('Kevin van Zonneveld')
  //       returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
  //       example 2: base64_encode('a')
  //       returns 2: 'YQ=='
  //       example 3: base64_encode('✓ à la mode')
  //       returns 3: '4pyTIMOgIGxhIG1vZGU='

  // encodeUTF8string()
  // Internal function to encode properly UTF8 string
  // Adapted from Solution #1 at https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
  const encodeUTF8string = function (str) {
    // first we use encodeURIComponent to get percent-encoded UTF-8,
    // then we convert the percent encodings into raw bytes which
    // can be fed into the base64 encoding algorithm.
    return encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function toSolidBytes(_match, p1) {
      return String.fromCharCode(Number.parseInt(p1, 16))
    })
  }

  const bufferValue = getPhpGlobalEntry('Buffer')
  if (isObjectLike(bufferValue)) {
    const bufferFrom = getPhpObjectEntry(bufferValue, 'from')
    if (isPhpCallable(bufferFrom)) {
      const encoded = bufferFrom.call(bufferValue, String(stringToEncode))
      if (typeof encoded === 'object' && encoded !== null) {
        const encodedToString = getPhpObjectEntry(encoded, 'toString')
        if (isPhpCallable(encodedToString)) {
          const base64Value = encodedToString.call(encoded, 'base64')
          if (typeof base64Value === 'string') {
            return base64Value
          }
        }
      }
    }
  }

  const btoaValue = getPhpGlobalCallable('btoa')
  if (btoaValue) {
    const encoded = btoaValue(encodeUTF8string(String(stringToEncode)))
    if (typeof encoded === 'string') {
      return encoded
    }
  }

  const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  let o1
  let o2
  let o3
  let h1
  let h2
  let h3
  let h4
  let bits
  let i = 0
  let ac = 0
  let enc = ''
  const tmpArr = []

  if (!stringToEncode) {
    return stringToEncode
  }

  stringToEncode = encodeUTF8string(stringToEncode)

  do {
    // pack three octets into four hexets
    o1 = stringToEncode.charCodeAt(i++)
    o2 = stringToEncode.charCodeAt(i++)
    o3 = stringToEncode.charCodeAt(i++)

    bits = (o1 << 16) | (o2 << 8) | o3

    h1 = (bits >> 18) & 0x3f
    h2 = (bits >> 12) & 0x3f
    h3 = (bits >> 6) & 0x3f
    h4 = bits & 0x3f

    // use hexets to index into b64, and append result to encoded string
    tmpArr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4)
  } while (i < stringToEncode.length)

  enc = tmpArr.join('')

  const r = stringToEncode.length % 3

  return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3)
}

// php/_helpers/_phpTypes (Locutus helper dependency)
type PhpNullish = null | undefined

type PhpInput = {} | PhpNullish

type PhpList<T = PhpInput> = T[]

type PhpAssoc<T = PhpInput> = { [key: string]: T }

type PhpArrayLike<T = PhpInput> = PhpList<T> | PhpAssoc<T>

type PhpCallableArgs = PhpInput[]

type PhpCallable<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput> = (
  ...args: TArgs
) => TResult

function isObjectLike(value: PhpInput): value is PhpArrayLike<PhpInput> {
  return typeof value === 'object' && value !== null
}

function isPhpCallable<TArgs extends PhpCallableArgs = PhpCallableArgs, TResult = PhpInput>(
  value: PhpInput,
): value is PhpCallable<TArgs, TResult> {
  return typeof value === 'function'
}

// php/_helpers/_phpRuntimeState (Locutus helper dependency)
interface LocutusRuntimeContainer {
  php?: PhpAssoc<PhpInput>
}

interface PhpGlobalProcessLike {
  env?: PhpAssoc<string | undefined>
}

interface PhpGlobalBufferLike {
  from?: (...args: PhpInput[]) => PhpInput
}

interface PhpGlobalKnownEntryMap {
  process: PhpGlobalProcessLike
  Buffer: PhpGlobalBufferLike
}

type GlobalWithLocutus = {
  $locutus?: LocutusRuntimeContainer
  [key: string]: PhpInput
}

const globalContext: GlobalWithLocutus =
  typeof window === 'object' && window !== null ? window : typeof global === 'object' && global !== null ? global : {}

function getPhpGlobalEntry<TKey extends keyof PhpGlobalKnownEntryMap>(
  key: TKey,
): PhpGlobalKnownEntryMap[TKey] | undefined

function getPhpGlobalEntry(key: string): PhpInput | undefined

function getPhpGlobalEntry(key: string): PhpInput | undefined {
  const value = globalContext[key]
  return typeof value === 'undefined' ? undefined : value
}

function getPhpGlobalCallable<TArgs extends PhpInput[] = PhpInput[], TResult = PhpInput>(
  key: string,
): PhpCallable<TArgs, TResult> | undefined {
  const value = getPhpGlobalEntry(key)
  return isPhpCallable<TArgs, TResult>(value) ? value : undefined
}

function getPhpObjectEntry(value: PhpInput, key: string): PhpInput | undefined {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return undefined
  }

  let current: object | null = value
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.get === 'function') {
        const getterValue = descriptor.get.call(value)
        return typeof getterValue === 'undefined' ? undefined : getterValue
      }
      const directValue = descriptor.value
      return typeof directValue === 'undefined' ? undefined : directValue
    }
    current = Object.getPrototypeOf(current)
  }

  return undefined
}

// php/url/base64_encode (target function module)
function base64_encode(stringToEncode: string | null | undefined): string | null | undefined {
  //      discuss at: https://locutus.io/php/base64_encode/
  // parity verified: PHP 8.3
  //     original by: Tyler Akins (https://rumkin.com)
  //     improved by: Bayron Guevara
  //     improved by: Thunder.m
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Rafał Kukawski (https://blog.kukawski.pl)
  //     bugfixed by: Pellentesque Malesuada
  //     improved by: Indigo744
  //       example 1: base64_encode('Kevin van Zonneveld')
  //       returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
  //       example 2: base64_encode('a')
  //       returns 2: 'YQ=='
  //       example 3: base64_encode('✓ à la mode')
  //       returns 3: '4pyTIMOgIGxhIG1vZGU='

  // encodeUTF8string()
  // Internal function to encode properly UTF8 string
  // Adapted from Solution #1 at https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
  const encodeUTF8string = function (str: string): string {
    // first we use encodeURIComponent to get percent-encoded UTF-8,
    // then we convert the percent encodings into raw bytes which
    // can be fed into the base64 encoding algorithm.
    return encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function toSolidBytes(_match, p1: string) {
      return String.fromCharCode(Number.parseInt(p1, 16))
    })
  }

  const bufferValue = getPhpGlobalEntry('Buffer')
  if (isObjectLike(bufferValue)) {
    const bufferFrom = getPhpObjectEntry(bufferValue, 'from')
    if (isPhpCallable<[string], object>(bufferFrom)) {
      const encoded = bufferFrom.call(bufferValue, String(stringToEncode))
      if (typeof encoded === 'object' && encoded !== null) {
        const encodedToString = getPhpObjectEntry(encoded, 'toString')
        if (isPhpCallable<[string], string>(encodedToString)) {
          const base64Value = encodedToString.call(encoded, 'base64')
          if (typeof base64Value === 'string') {
            return base64Value
          }
        }
      }
    }
  }

  const btoaValue = getPhpGlobalCallable<[string], string>('btoa')
  if (btoaValue) {
    const encoded = btoaValue(encodeUTF8string(String(stringToEncode)))
    if (typeof encoded === 'string') {
      return encoded
    }
  }

  const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  let o1: number
  let o2: number
  let o3: number
  let h1: number
  let h2: number
  let h3: number
  let h4: number
  let bits: number
  let i = 0
  let ac = 0
  let enc = ''
  const tmpArr: string[] = []

  if (!stringToEncode) {
    return stringToEncode
  }

  stringToEncode = encodeUTF8string(stringToEncode)

  do {
    // pack three octets into four hexets
    o1 = stringToEncode.charCodeAt(i++)
    o2 = stringToEncode.charCodeAt(i++)
    o3 = stringToEncode.charCodeAt(i++)

    bits = (o1 << 16) | (o2 << 8) | o3

    h1 = (bits >> 18) & 0x3f
    h2 = (bits >> 12) & 0x3f
    h3 = (bits >> 6) & 0x3f
    h4 = bits & 0x3f

    // use hexets to index into b64, and append result to encoded string
    tmpArr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4)
  } while (i < stringToEncode.length)

  enc = tmpArr.join('')

  const r = stringToEncode.length % 3

  return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3)
}

// php/_helpers/_phpTypes (Locutus helper dependency)
function isObjectLike(value) {
  return typeof value === 'object' && value !== null
}

function isPhpCallable(value) {
  return typeof value === 'function'
}

// php/_helpers/_phpRuntimeState (Locutus helper dependency)
const globalContext =
  typeof window === 'object' && window !== null ? window : typeof global === 'object' && global !== null ? global : {}

function getPhpGlobalEntry(key) {
  const value = globalContext[key]
  return typeof value === 'undefined' ? undefined : value
}

function getPhpGlobalCallable(key) {
  const value = getPhpGlobalEntry(key)
  return isPhpCallable(value) ? value : undefined
}

function getPhpObjectEntry(value, key) {
  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
    return undefined
  }

  let current = value
  while (current) {
    const descriptor = Object.getOwnPropertyDescriptor(current, key)
    if (descriptor) {
      if (typeof descriptor.get === 'function') {
        const getterValue = descriptor.get.call(value)
        return typeof getterValue === 'undefined' ? undefined : getterValue
      }
      const directValue = descriptor.value
      return typeof directValue === 'undefined' ? undefined : directValue
    }
    current = Object.getPrototypeOf(current)
  }

  return undefined
}

// php/url/base64_encode (target function module)
function base64_encode(stringToEncode) {
  //      discuss at: https://locutus.io/php/base64_encode/
  // parity verified: PHP 8.3
  //     original by: Tyler Akins (https://rumkin.com)
  //     improved by: Bayron Guevara
  //     improved by: Thunder.m
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Kevin van Zonneveld (https://kvz.io)
  //     improved by: Rafał Kukawski (https://blog.kukawski.pl)
  //     bugfixed by: Pellentesque Malesuada
  //     improved by: Indigo744
  //       example 1: base64_encode('Kevin van Zonneveld')
  //       returns 1: 'S2V2aW4gdmFuIFpvbm5ldmVsZA=='
  //       example 2: base64_encode('a')
  //       returns 2: 'YQ=='
  //       example 3: base64_encode('✓ à la mode')
  //       returns 3: '4pyTIMOgIGxhIG1vZGU='

  // encodeUTF8string()
  // Internal function to encode properly UTF8 string
  // Adapted from Solution #1 at https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
  const encodeUTF8string = function (str) {
    // first we use encodeURIComponent to get percent-encoded UTF-8,
    // then we convert the percent encodings into raw bytes which
    // can be fed into the base64 encoding algorithm.
    return encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function toSolidBytes(_match, p1) {
      return String.fromCharCode(Number.parseInt(p1, 16))
    })
  }

  const bufferValue = getPhpGlobalEntry('Buffer')
  if (isObjectLike(bufferValue)) {
    const bufferFrom = getPhpObjectEntry(bufferValue, 'from')
    if (isPhpCallable(bufferFrom)) {
      const encoded = bufferFrom.call(bufferValue, String(stringToEncode))
      if (typeof encoded === 'object' && encoded !== null) {
        const encodedToString = getPhpObjectEntry(encoded, 'toString')
        if (isPhpCallable(encodedToString)) {
          const base64Value = encodedToString.call(encoded, 'base64')
          if (typeof base64Value === 'string') {
            return base64Value
          }
        }
      }
    }
  }

  const btoaValue = getPhpGlobalCallable('btoa')
  if (btoaValue) {
    const encoded = btoaValue(encodeUTF8string(String(stringToEncode)))
    if (typeof encoded === 'string') {
      return encoded
    }
  }

  const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  let o1
  let o2
  let o3
  let h1
  let h2
  let h3
  let h4
  let bits
  let i = 0
  let ac = 0
  let enc = ''
  const tmpArr = []

  if (!stringToEncode) {
    return stringToEncode
  }

  stringToEncode = encodeUTF8string(stringToEncode)

  do {
    // pack three octets into four hexets
    o1 = stringToEncode.charCodeAt(i++)
    o2 = stringToEncode.charCodeAt(i++)
    o3 = stringToEncode.charCodeAt(i++)

    bits = (o1 << 16) | (o2 << 8) | o3

    h1 = (bits >> 18) & 0x3f
    h2 = (bits >> 12) & 0x3f
    h3 = (bits >> 6) & 0x3f
    h4 = bits & 0x3f

    // use hexets to index into b64, and append result to encoded string
    tmpArr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4)
  } while (i < stringToEncode.length)

  enc = tmpArr.join('')

  const r = stringToEncode.length % 3

  return (r ? enc.slice(0, r - 3) : enc) + '==='.slice(r || 3)
}

Improve this function

Locutus is a community effort following The McDonald's Theory: we ship first iterations, hoping others will improve them. If you see something that could be better, we'd love your contribution.

View on GitHub · Edit on GitHub · View Raw

---

« More PHP url functions

Star