encoding.utf8

/**
 * Text as UTF-8 bytes. Written out rather than using TextEncoder so the
 * registry's TypeScript needs no DOM or Node typings; it gives the same
 * answer, including U+FFFD for a lone surrogate.
 */
export function utf8Encode(text: string): readonly number[] {
  if (typeof text !== "string") {
    throw new TypeError("text must be a string");
  }
  const out: number[] = [];
  for (let i = 0; i < text.length; i++) {
    let cp = text.charCodeAt(i);
    if (cp >= 0xd800 && cp <= 0xdbff && i + 1 < text.length) {
      const next = text.charCodeAt(i + 1);
      if (next >= 0xdc00 && next <= 0xdfff) {
        cp = 0x10000 + ((cp - 0xd800) << 10) + (next - 0xdc00);
        i++;
      }
    }
    // Anything still in the surrogate range is half a pair with no partner.
    if (cp >= 0xd800 && cp <= 0xdfff) cp = 0xfffd;
    if (cp < 0x80) {
      out.push(cp);
    } else if (cp < 0x800) {
      out.push(0xc0 | (cp >> 6), 0x80 | (cp & 63));
    } else if (cp < 0x10000) {
      out.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
    } else {
      out.push(0xf0 | (cp >> 18), 0x80 | ((cp >> 12) & 63), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
    }
  }
  return out;
}

const INVALID = "bytes are not valid UTF-8";

/**
 * UTF-8 bytes back to text, strictly (RFC 3629): overlong forms, encoded
 * surrogates, code points past U+10FFFF, truncated sequences and stray
 * continuation bytes are errors. A leading byte order mark is kept.
 */
export function utf8Decode(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;
  while (i < bytes.length) {
    const b0 = bytes[i];
    let cp: number;
    let need: number;
    let min: number;
    if (b0 < 0x80) {
      out += String.fromCharCode(b0);
      i++;
      continue;
    } else if (b0 >= 0xc2 && b0 <= 0xdf) {
      cp = b0 & 0x1f;
      need = 1;
      min = 0x80;
    } else if (b0 >= 0xe0 && b0 <= 0xef) {
      cp = b0 & 0x0f;
      need = 2;
      min = 0x800;
    } else if (b0 >= 0xf0 && b0 <= 0xf4) {
      cp = b0 & 0x07;
      need = 3;
      min = 0x10000;
    } else {
      // 80-BF continuation with no lead, C0/C1 (always overlong), F5-FF.
      throw new RangeError(INVALID);
    }
    if (i + need >= bytes.length) throw new RangeError(INVALID);
    for (let k = 1; k <= need; k++) {
      const b = bytes[i + k];
      if ((b & 0xc0) !== 0x80) throw new RangeError(INVALID);
      cp = (cp << 6) | (b & 0x3f);
    }
    if (cp < min || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) {
      throw new RangeError(INVALID);
    }
    out += String.fromCodePoint(cp);
    i += need + 1;
  }
  return out;
}