encoding.base64

const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/**
 * Bytes as standard base64 (RFC 4648 section 4), padded with "=".
 *
 * Written out rather than using btoa, which takes a "binary string" and
 * throws on anything above 0xff, and Buffer, which is not in the browser.
 */
export function base64Encode(bytes: readonly number[]): string {
  if (!Array.isArray(bytes) && !(bytes instanceof Uint8Array)) {
    throw new TypeError("bytes must be a list of integers from 0 to 255");
  }
  for (let i = 0; i < bytes.length; i++) {
    const b = bytes[i];
    if (typeof b !== "number" || !Number.isInteger(b) || b < 0 || b > 255) {
      throw new RangeError("bytes must be a list of integers from 0 to 255");
    }
  }
  let out = "";
  let i = 0;
  for (; i + 3 <= bytes.length; i += 3) {
    const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
    out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + ALPHABET[(n >> 6) & 63] + ALPHABET[n & 63];
  }
  const rest = bytes.length - i;
  if (rest === 1) {
    const n = bytes[i] << 16;
    out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + "==";
  } else if (rest === 2) {
    const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
    out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63] + ALPHABET[(n >> 6) & 63] + "=";
  }
  return out;
}

function sextet(code: number): number {
  if (code >= 65 && code <= 90) return code - 65; // A-Z
  if (code >= 97 && code <= 122) return code - 71; // a-z
  if (code >= 48 && code <= 57) return code + 4; // 0-9
  if (code === 43) return 62; // +
  if (code === 47) return 63; // /
  return -1;
}

/**
 * Standard, padded base64 back to bytes, strictly: no whitespace, no
 * characters outside the alphabet, padding to a multiple of four, and zero
 * bits after the last byte, so every byte string has exactly one spelling.
 */
export function base64Decode(text: string): readonly number[] {
  if (typeof text !== "string") {
    throw new TypeError("base64 text must be a string");
  }
  const values: number[] = [];
  let padding = 0;
  for (let i = 0; i < text.length; i++) {
    const code = text.charCodeAt(i);
    if (code === 61) {
      padding++;
      continue;
    }
    const v = sextet(code);
    if (v < 0 || padding > 0) {
      throw new RangeError("base64 text may only contain A-Z, a-z, 0-9, + and /, with = padding at the end");
    }
    values.push(v);
  }
  if (text.length % 4 !== 0) {
    throw new RangeError(`base64 text must be a multiple of 4 characters long, received ${text.length}`);
  }
  if (padding > 2) {
    throw new RangeError("base64 text has too much = padding");
  }
  const out: number[] = [];
  let i = 0;
  for (; i + 4 <= values.length; i += 4) {
    const n = (values[i] << 18) | (values[i + 1] << 12) | (values[i + 2] << 6) | values[i + 3];
    out.push((n >> 16) & 255, (n >> 8) & 255, n & 255);
  }
  const rest = values.length - i;
  if (rest === 2) {
    if ((values[i + 1] & 15) !== 0) throw new RangeError("base64 text has non-zero bits after its last byte");
    out.push(((values[i] << 2) | (values[i + 1] >> 4)) & 255);
  } else if (rest === 3) {
    if ((values[i + 2] & 3) !== 0) throw new RangeError("base64 text has non-zero bits after its last byte");
    const n = (values[i] << 18) | (values[i + 1] << 12) | (values[i + 2] << 6);
    out.push((n >> 16) & 255, (n >> 8) & 255);
  }
  return out;
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { base64Encode } from "./encoding_base64_base64_encode.ts";  ← base64Encode, another function of this group · built into the same file, even by a slim install

/**
 * Bytes as base64url (RFC 4648 section 5) without padding: the alphabet with
 * "-" and "_" in place of "+" and "/", as JWTs and URL tokens use it.
 */
export function base64UrlEncode(bytes: readonly number[]): string {
  const standard = base64Encode(bytes);
  let out = "";
  for (let i = 0; i < standard.length; i++) {
    const ch = standard[i];
    if (ch === "=") break;
    out += ch === "+" ? "-" : ch === "/" ? "_" : ch;
  }
  return out;
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

import { base64Decode } from "./encoding_base64_base64_decode.ts";  ← base64Decode, another function of this group · built into the same file, even by a slim install

/**
 * base64url text back to bytes. Padding is optional, since JWTs leave it
 * off and some producers keep it, but padding that is present must be right.
 */
export function base64UrlDecode(text: string): readonly number[] {
  if (typeof text !== "string") {
    throw new TypeError("base64url text must be a string");
  }
  let body = "";
  let padding = 0;
  for (let i = 0; i < text.length; i++) {
    const ch = text[i];
    if (ch === "=") {
      padding++;
      continue;
    }
    const code = text.charCodeAt(i);
    const ok = (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || (code >= 48 && code <= 57) || ch === "-" || ch === "_";
    if (!ok || padding > 0) {
      throw new RangeError("base64url text may only contain A-Z, a-z, 0-9, - and _, with optional = padding at the end");
    }
    body += ch === "-" ? "+" : ch === "_" ? "/" : ch;
  }
  if (body.length % 4 === 1) {
    throw new RangeError(`base64url text cannot be ${body.length} characters long; no number of bytes encodes to that`);
  }
  const needed = (4 - (body.length % 4)) % 4;
  if (padding !== 0 && padding !== needed) {
    throw new RangeError("base64url text has the wrong amount of = padding");
  }
  return base64Decode(body + "=".repeat(needed));
}