encoding.hex

const DIGITS = "0123456789abcdef";

/**
 * Bytes as lowercase hexadecimal, two digits per byte.
 *
 * Bytes are a list of integers 0-255 across the registry (there is no bytes
 * type), so a value outside that range is refused rather than masked to a
 * byte: 256 quietly becoming 0 would change key material without a trace.
 */
export function hexEncode(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");
  }
  let out = "";
  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");
    }
    out += DIGITS[b >> 4] + DIGITS[b & 15];
  }
  return out;
}

function digitValue(code: number): number {
  if (code >= 48 && code <= 57) return code - 48; // 0-9
  if (code >= 97 && code <= 102) return code - 87; // a-f
  if (code >= 65 && code <= 70) return code - 55; // A-F
  return -1;
}

/**
 * Hexadecimal text back to bytes. Either case is accepted, since RFC 4648
 * prints its vectors in uppercase and most tools print lowercase; anything
 * else (a 0x prefix, whitespace, an odd digit count) is an error, not skipped.
 */
export function hexDecode(text: string): readonly number[] {
  if (typeof text !== "string") {
    throw new TypeError("hex text must be a string");
  }
  // Characters are checked before the length, so the answer for non-ASCII
  // input does not depend on how a language counts its length.
  const digits: number[] = [];
  for (let i = 0; i < text.length; i++) {
    const d = digitValue(text.charCodeAt(i));
    if (d < 0) {
      throw new RangeError("hex text may only contain the digits 0-9, a-f and A-F");
    }
    digits.push(d);
  }
  if (digits.length % 2 !== 0) {
    throw new RangeError(`hex text must have an even number of digits, received ${digits.length}`);
  }
  const out: number[] = [];
  for (let i = 0; i < digits.length; i += 2) out.push(digits[i] * 16 + digits[i + 1]);
  return out;
}