@fulmenhq/tsfulmen 0.2.0 → 0.2.2

package/dist/fulencode/index.js

@@ -0,0 +1,806 @@
+import { crc32, xxhash128 } from 'hash-wasm';
+import { createHash } from 'crypto';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/crucible/fulhash/types.ts
+var Algorithm;
+var init_types = __esm({
+  "src/crucible/fulhash/types.ts"() {
+    Algorithm = /* @__PURE__ */ ((Algorithm2) => {
+      Algorithm2["XXH3_128"] = "xxh3-128";
+      Algorithm2["SHA256"] = "sha256";
+      Algorithm2["CRC32"] = "crc32";
+      Algorithm2["CRC32C"] = "crc32c";
+      return Algorithm2;
+    })(Algorithm || {});
+  }
+});
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    bytes[i] = Number.parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+async function hashBytes(data) {
+  const hex = await crc32(data);
+  return hexToBytes(hex);
+}
+async function hashString(str, encoding = "utf8") {
+  if (encoding !== "utf8") {
+    const buf = Buffer.from(str, encoding);
+    const hex2 = await crc32(buf);
+    return hexToBytes(hex2);
+  }
+  const hex = await crc32(str);
+  return hexToBytes(hex);
+}
+var init_crc32 = __esm({
+  "src/fulhash/algorithms/crc32.ts"() {
+  }
+});
+function hexToBytes2(hex) {
+  const bytes = new Uint8Array(4);
+  for (let i = 0; i < 4; i++) {
+    bytes[i] = Number.parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+async function hashBytes2(data) {
+  const hex = await crc32(data, CRC32C_POLYNOMIAL);
+  return hexToBytes2(hex);
+}
+async function hashString2(str, encoding = "utf8") {
+  if (encoding !== "utf8") {
+    const buf = Buffer.from(str, encoding);
+    const hex2 = await crc32(buf, CRC32C_POLYNOMIAL);
+    return hexToBytes2(hex2);
+  }
+  const hex = await crc32(str, CRC32C_POLYNOMIAL);
+  return hexToBytes2(hex);
+}
+var CRC32C_POLYNOMIAL;
+var init_crc32c = __esm({
+  "src/fulhash/algorithms/crc32c.ts"() {
+    CRC32C_POLYNOMIAL = 2197175160;
+  }
+});
+function hashBytes3(data) {
+  const hash2 = createHash("sha256");
+  hash2.update(data);
+  return new Uint8Array(hash2.digest());
+}
+function hashString3(str, encoding = "utf8") {
+  const hash2 = createHash("sha256");
+  hash2.update(str, encoding);
+  return new Uint8Array(hash2.digest());
+}
+var init_sha256 = __esm({
+  "src/fulhash/algorithms/sha256.ts"() {
+  }
+});
+
+// src/fulhash/errors.ts
+var FulHashError, UnsupportedAlgorithmError, InvalidChecksumError, InvalidChecksumFormatError;
+var init_errors = __esm({
+  "src/fulhash/errors.ts"() {
+    FulHashError = class _FulHashError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "FulHashError";
+        Object.setPrototypeOf(this, _FulHashError.prototype);
+      }
+    };
+    UnsupportedAlgorithmError = class _UnsupportedAlgorithmError extends FulHashError {
+      constructor(algorithm, supportedAlgorithms) {
+        super(
+          `Unsupported algorithm "${algorithm}". Supported algorithms: ${supportedAlgorithms.join(", ")}`
+        );
+        this.name = "UnsupportedAlgorithmError";
+        Object.setPrototypeOf(this, _UnsupportedAlgorithmError.prototype);
+      }
+    };
+    InvalidChecksumError = class _InvalidChecksumError extends FulHashError {
+      constructor(checksum, reason) {
+        super(`Invalid checksum "${checksum}": ${reason}. Expected format: algorithm:hex`);
+        this.name = "InvalidChecksumError";
+        Object.setPrototypeOf(this, _InvalidChecksumError.prototype);
+      }
+    };
+    InvalidChecksumFormatError = class _InvalidChecksumFormatError extends InvalidChecksumError {
+      constructor(checksum, reason) {
+        super(checksum, reason);
+        this.name = "InvalidChecksumFormatError";
+        Object.setPrototypeOf(this, _InvalidChecksumFormatError.prototype);
+      }
+    };
+  }
+});
+function hexToBytes3(hex) {
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) {
+    bytes[i] = Number.parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+async function hashBytes4(data) {
+  const hex = await xxhash128(data);
+  return hexToBytes3(hex);
+}
+async function hashString4(str, encoding = "utf8") {
+  if (encoding !== "utf8") {
+    throw new FulHashError(
+      "XXH3-128 only supports UTF-8 encoding. Use utf8 encoding or convert data to Uint8Array."
+    );
+  }
+  const hex = await xxhash128(str);
+  return hexToBytes3(hex);
+}
+var init_xxh3 = __esm({
+  "src/fulhash/algorithms/xxh3.ts"() {
+    init_errors();
+  }
+});
+
+// src/fulhash/digest.ts
+var Digest;
+var init_digest = __esm({
+  "src/fulhash/digest.ts"() {
+    init_types();
+    init_errors();
+    Digest = class _Digest {
+      algorithm;
+      _bytes;
+      hex;
+      formatted;
+      constructor(algorithm, bytes) {
+        this.algorithm = algorithm;
+        this._bytes = new Uint8Array(bytes);
+        this.hex = Array.from(this._bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        this.formatted = `${this.algorithm}:${this.hex}`;
+        Object.freeze(this);
+      }
+      get bytes() {
+        return Array.from(this._bytes);
+      }
+      toJSON() {
+        return {
+          algorithm: this.algorithm,
+          hex: this.hex,
+          formatted: this.formatted
+        };
+      }
+      toString() {
+        return this.formatted;
+      }
+      static parse(formatted) {
+        if (!formatted.includes(":")) {
+          throw new InvalidChecksumFormatError(formatted, "missing separator");
+        }
+        const [algorithmStr, hex] = formatted.split(":", 2);
+        if (!algorithmStr || !hex) {
+          throw new InvalidChecksumFormatError(formatted, "invalid format");
+        }
+        const algorithm = algorithmStr;
+        if (!Object.values(Algorithm).includes(algorithm)) {
+          throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
+        }
+        if (!/^[0-9a-f]+$/.test(hex)) {
+          throw new InvalidChecksumError(
+            formatted,
+            "hex must contain only lowercase hexadecimal characters"
+          );
+        }
+        let expectedLength;
+        switch (algorithm) {
+          case "xxh3-128" /* XXH3_128 */:
+            expectedLength = 32;
+            break;
+          case "sha256" /* SHA256 */:
+            expectedLength = 64;
+            break;
+          case "crc32" /* CRC32 */:
+          case "crc32c" /* CRC32C */:
+            expectedLength = 8;
+            break;
+          default:
+            throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
+        }
+        if (hex.length !== expectedLength) {
+          throw new InvalidChecksumError(
+            formatted,
+            `invalid hex length for ${algorithm}: expected ${expectedLength}, got ${hex.length}`
+          );
+        }
+        const bytes = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length; i += 2) {
+          bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
+        }
+        return new _Digest(algorithm, bytes);
+      }
+      equals(other) {
+        if (this.algorithm !== other.algorithm) {
+          return false;
+        }
+        if (this.hex !== other.hex) {
+          return false;
+        }
+        return true;
+      }
+      static async verify(data, checksum) {
+        const expected = _Digest.parse(checksum);
+        const { hash: hash2 } = await Promise.resolve().then(() => (init_hash(), hash_exports));
+        const actual = await hash2(data, { algorithm: expected.algorithm });
+        return actual.equals(expected);
+      }
+    };
+  }
+});
+
+// src/fulhash/hash.ts
+var hash_exports = {};
+__export(hash_exports, {
+  hash: () => hash,
+  hashBytes: () => hashBytes5,
+  hashString: () => hashString5
+});
+async function hash(input, options) {
+  const algorithm = options?.algorithm ?? "xxh3-128" /* XXH3_128 */;
+  const encoding = options?.encoding ?? "utf8";
+  let bytes;
+  switch (algorithm) {
+    case "sha256" /* SHA256 */:
+      if (typeof input === "string") {
+        bytes = hashString3(input, encoding);
+      } else {
+        bytes = hashBytes3(input);
+      }
+      break;
+    case "xxh3-128" /* XXH3_128 */:
+      if (typeof input === "string") {
+        if (encoding !== "utf8") {
+          bytes = await hashBytes4(Buffer.from(input, encoding));
+        } else {
+          bytes = await hashString4(input, "utf8");
+        }
+      } else {
+        bytes = await hashBytes4(input);
+      }
+      break;
+    case "crc32" /* CRC32 */:
+      if (typeof input === "string") {
+        bytes = await hashString(input, encoding);
+      } else {
+        bytes = await hashBytes(input);
+      }
+      break;
+    case "crc32c" /* CRC32C */:
+      if (typeof input === "string") {
+        bytes = await hashString2(input, encoding);
+      } else {
+        bytes = await hashBytes2(input);
+      }
+      break;
+    default:
+      throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
+  }
+  return new Digest(algorithm, bytes);
+}
+async function hashString5(str, options) {
+  return hash(str, options);
+}
+async function hashBytes5(data, options) {
+  return hash(data, options);
+}
+var init_hash = __esm({
+  "src/fulhash/hash.ts"() {
+    init_types();
+    init_crc32();
+    init_crc32c();
+    init_sha256();
+    init_xxh3();
+    init_digest();
+    init_errors();
+  }
+});
+
+// src/fulencode/errors.ts
+var FulencodeError = class extends Error {
+  code;
+  operation;
+  inputFormat;
+  outputFormat;
+  details;
+  constructor(args) {
+    super(args.message);
+    this.name = "FulencodeError";
+    this.code = args.code;
+    this.operation = args.operation;
+    this.inputFormat = args.inputFormat;
+    this.outputFormat = args.outputFormat;
+    this.details = args.details;
+    if (args.cause !== void 0) {
+      this.cause = args.cause;
+    }
+  }
+};
+
+// src/fulencode/types.ts
+var EncodingFormat = {
+  BASE64: "base64",
+  BASE64URL: "base64url",
+  BASE64_RAW: "base64_raw",
+  BASE32: "base32",
+  BASE32HEX: "base32hex",
+  HEX: "hex",
+  UTF8: "utf-8",
+  UTF16LE: "utf-16le",
+  UTF16BE: "utf-16be",
+  ISO_8859_1: "iso-8859-1",
+  CP1252: "cp1252",
+  ASCII: "ascii"
+};
+
+// src/fulencode/fulencode.ts
+init_types();
+init_hash();
+
+// src/fulencode/base32.ts
+var RFC4648_BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+var RFC4648_BASE32HEX_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+function getAlphabet(variant) {
+  return variant === "base32" ? RFC4648_BASE32_ALPHABET : RFC4648_BASE32HEX_ALPHABET;
+}
+function encodeBase32(data, variant, options) {
+  if (data.length === 0) return "";
+  const alphabet = getAlphabet(variant);
+  let bits = 0;
+  let value = 0;
+  let out = "";
+  for (const b of data) {
+    value = value << 8 | b;
+    bits += 8;
+    while (bits >= 5) {
+      const idx = value >>> bits - 5 & 31;
+      out += alphabet[idx];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) {
+    const idx = value << 5 - bits & 31;
+    out += alphabet[idx];
+  }
+  if (options.padding) {
+    while (out.length % 8 !== 0) out += "=";
+  }
+  return out;
+}
+function buildDecodeMap(alphabet) {
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < alphabet.length; i++) {
+    const ch = alphabet[i];
+    map.set(ch, i);
+    map.set(ch.toLowerCase(), i);
+  }
+  return map;
+}
+function decodeBase32(input, variant, options) {
+  const alphabet = getAlphabet(variant);
+  const decodeMap = buildDecodeMap(alphabet);
+  let s = input;
+  if (options.ignoreWhitespace) {
+    s = s.replace(/[\n\r\t\s]/g, "");
+  }
+  const firstPad = s.indexOf("=");
+  if (firstPad !== -1) {
+    if (options.validatePadding) {
+      for (let i = firstPad; i < s.length; i++) {
+        if (s[i] !== "=") {
+          throw new Error("Invalid base32 padding");
+        }
+      }
+      if (s.length % 8 !== 0) {
+        throw new Error("Invalid base32 length (padding)");
+      }
+    }
+    s = s.slice(0, firstPad);
+  }
+  let bits = 0;
+  let value = 0;
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    const v = decodeMap.get(ch);
+    if (v === void 0) {
+      throw new Error(`Invalid base32 character: ${ch}`);
+    }
+    value = value << 5 | v;
+    bits += 5;
+    if (bits >= 8) {
+      out.push(value >>> bits - 8 & 255);
+      bits -= 8;
+    }
+  }
+  return Uint8Array.from(out);
+}
+
+// src/fulencode/fulencode.ts
+function wrapLines(data, lineLength, lineEnding) {
+  if (lineLength <= 0) return data;
+  let out = "";
+  for (let i = 0; i < data.length; i += lineLength) {
+    out += data.slice(i, i + lineLength);
+    if (i + lineLength < data.length) out += lineEnding;
+  }
+  return out;
+}
+function requireBytes(input, format) {
+  if (typeof input === "string") {
+    throw new FulencodeError({
+      code: "INVALID_INPUT_TYPE",
+      message: `Format '${format}' requires binary input (Uint8Array)`,
+      operation: "encode",
+      outputFormat: format,
+      details: { expected: "Uint8Array", actual: "string" }
+    });
+  }
+  return input;
+}
+function normalizeWhitespace(input, ignoreWhitespace) {
+  if (!ignoreWhitespace) return input;
+  return input.replace(/[\n\r\t\s]/g, "");
+}
+function base64FromBytes(data) {
+  return Buffer.from(data).toString("base64");
+}
+function base64UrlFromBytes(data) {
+  return base64FromBytes(data).replace(/\+/g, "-").replace(/\//g, "_");
+}
+function applyBase64Padding(s, padding) {
+  return padding ? s.padEnd(Math.ceil(s.length / 4) * 4, "=") : s.replace(/=+$/g, "");
+}
+function decodeBase64Strict(input, variant, validatePadding) {
+  const allowed = variant === "base64" ? /^[A-Za-z0-9+/]*={0,2}$/ : /^[A-Za-z0-9\-_]*={0,2}$/;
+  if (!allowed.test(input)) {
+    throw new Error("Invalid base64 characters");
+  }
+  if (validatePadding) {
+    if (input.length % 4 !== 0) {
+      throw new Error("Invalid base64 length");
+    }
+    const firstPad = input.indexOf("=");
+    if (firstPad !== -1) {
+      for (let i = firstPad; i < input.length; i++) {
+        if (input[i] !== "=") throw new Error("Invalid base64 padding");
+      }
+    }
+  }
+  const s = variant === "base64url" ? input.replace(/-/g, "+").replace(/_/g, "/") : input;
+  return Uint8Array.from(Buffer.from(s, "base64"));
+}
+async function computeChecksumIfRequested(data, algorithm) {
+  if (!algorithm) return {};
+  if (algorithm !== "sha256" && algorithm !== "xxh3-128") {
+    throw new FulencodeError({
+      code: "UNSUPPORTED_CHECKSUM",
+      message: `Unsupported checksum algorithm: ${algorithm}`,
+      operation: "encode",
+      details: { algorithm }
+    });
+  }
+  const digest = await hashBytes5(data, {
+    algorithm: algorithm === "sha256" ? "sha256" /* SHA256 */ : "xxh3-128" /* XXH3_128 */
+  });
+  return { checksum: digest.toString(), checksumAlgorithm: algorithm };
+}
+async function encode(input, format, options = {}) {
+  const warnings = [];
+  if (options.embedChecksum) {
+    throw new FulencodeError({
+      code: "UNSUPPORTED_FEATURE",
+      message: "embedChecksum is not implemented in tsfulmen yet",
+      operation: "encode",
+      outputFormat: format
+    });
+  }
+  const padding = options.padding ?? true;
+  const lineLength = options.lineLength ?? null;
+  const lineEnding = options.lineEnding ?? "\n";
+  const maxEncodedSize = options.maxEncodedSize ?? 500 * 1024 * 1024;
+  const onError = options.onError ?? "strict";
+  let data;
+  let inputBytes;
+  try {
+    switch (format) {
+      case "base64": {
+        inputBytes = requireBytes(input, format);
+        data = applyBase64Padding(base64FromBytes(inputBytes), padding);
+        break;
+      }
+      case "base64url": {
+        inputBytes = requireBytes(input, format);
+        data = applyBase64Padding(base64UrlFromBytes(inputBytes), padding);
+        break;
+      }
+      case "base64_raw": {
+        inputBytes = requireBytes(input, format);
+        data = applyBase64Padding(base64FromBytes(inputBytes), false);
+        break;
+      }
+      case "hex": {
+        inputBytes = requireBytes(input, format);
+        const hex = Buffer.from(inputBytes).toString("hex");
+        data = (options.hexCase ?? "lower") === "upper" ? hex.toUpperCase() : hex;
+        break;
+      }
+      case "base32":
+      case "base32hex": {
+        inputBytes = requireBytes(input, format);
+        data = encodeBase32(inputBytes, format, { padding });
+        break;
+      }
+      case "utf-8": {
+        if (typeof input === "string") {
+          data = input;
+          inputBytes = new TextEncoder().encode(input);
+          warnings.push("string_input_passthrough");
+        } else {
+          inputBytes = input;
+          if (onError === "strict") {
+            data = new TextDecoder("utf-8", { fatal: true }).decode(inputBytes);
+          } else {
+            data = new TextDecoder("utf-8", { fatal: false }).decode(inputBytes);
+          }
+        }
+        break;
+      }
+      case "utf-16le": {
+        if (typeof input === "string") {
+          data = input;
+          inputBytes = Uint8Array.from(Buffer.from(input, "utf16le"));
+          warnings.push("string_input_passthrough");
+        } else {
+          inputBytes = input;
+          data = Buffer.from(inputBytes).toString("utf16le");
+        }
+        break;
+      }
+      case "utf-16be": {
+        if (typeof input === "string") {
+          data = input;
+          const le = Buffer.from(input, "utf16le");
+          for (let i = 0; i + 1 < le.length; i += 2) {
+            const a = le[i];
+            le[i] = le[i + 1];
+            le[i + 1] = a;
+          }
+          inputBytes = Uint8Array.from(le);
+          warnings.push("string_input_passthrough");
+        } else {
+          inputBytes = input;
+          const swapped = Buffer.from(inputBytes);
+          for (let i = 0; i + 1 < swapped.length; i += 2) {
+            const a = swapped[i];
+            swapped[i] = swapped[i + 1];
+            swapped[i + 1] = a;
+          }
+          data = swapped.toString("utf16le");
+        }
+        break;
+      }
+      case "iso-8859-1": {
+        if (typeof input === "string") {
+          data = input;
+          inputBytes = Uint8Array.from(Buffer.from(input, "latin1"));
+          warnings.push("string_input_passthrough");
+        } else {
+          inputBytes = input;
+          data = Buffer.from(inputBytes).toString("latin1");
+        }
+        break;
+      }
+      case "ascii": {
+        if (typeof input === "string") {
+          data = input;
+          inputBytes = Uint8Array.from(Buffer.from(input, "ascii"));
+          warnings.push("string_input_passthrough");
+        } else {
+          inputBytes = input;
+          data = Buffer.from(inputBytes).toString("ascii");
+        }
+        break;
+      }
+      case "cp1252": {
+        throw new FulencodeError({
+          code: "UNSUPPORTED_FORMAT",
+          message: "cp1252 is not implemented in tsfulmen yet",
+          operation: "encode",
+          outputFormat: format
+        });
+      }
+      default: {
+        throw new FulencodeError({
+          code: "UNSUPPORTED_FORMAT",
+          message: `Unsupported encoding format: ${format}`,
+          operation: "encode",
+          outputFormat: format
+        });
+      }
+    }
+  } catch (err) {
+    if (err instanceof FulencodeError) throw err;
+    throw new FulencodeError({
+      code: "ENCODE_FAILED",
+      message: err.message,
+      operation: "encode",
+      outputFormat: format,
+      cause: err
+    });
+  }
+  if (lineLength !== null) {
+    data = wrapLines(data, lineLength, lineEnding);
+  }
+  if (data.length > maxEncodedSize) {
+    throw new FulencodeError({
+      code: "OUTPUT_TOO_LARGE",
+      message: `Encoded output exceeds maxEncodedSize (${maxEncodedSize})`,
+      operation: "encode",
+      outputFormat: format,
+      details: { maxEncodedSize, outputSize: data.length }
+    });
+  }
+  const checksum = await computeChecksumIfRequested(inputBytes, options.computeChecksum);
+  return {
+    data,
+    format,
+    inputSize: inputBytes.length,
+    outputSize: data.length,
+    warnings,
+    ...checksum
+  };
+}
+async function decode(input, format, options = {}) {
+  const warnings = [];
+  const ignoreWhitespace = options.ignoreWhitespace ?? (format === "base64" || format === "base64url" || format === "hex" || format === "base32" || format === "base32hex");
+  const validatePadding = options.validatePadding ?? (format === "base64" || format === "base64url" || format === "base32" || format === "base32hex");
+  const maxDecodedSize = options.maxDecodedSize ?? 100 * 1024 * 1024;
+  const onError = options.onError ?? "strict";
+  const inputStr = typeof input === "string" ? input : Buffer.from(input).toString("utf8");
+  const normalized = normalizeWhitespace(inputStr, ignoreWhitespace);
+  let decoded;
+  const correctionsApplied = 0;
+  try {
+    switch (format) {
+      case "base64": {
+        const s = applyBase64Padding(normalized, true);
+        decoded = onError === "strict" ? decodeBase64Strict(s, "base64", validatePadding) : Uint8Array.from(Buffer.from(s, "base64"));
+        break;
+      }
+      case "base64url": {
+        const s = applyBase64Padding(normalized, true);
+        decoded = onError === "strict" ? decodeBase64Strict(s, "base64url", validatePadding) : Uint8Array.from(Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64"));
+        break;
+      }
+      case "base64_raw": {
+        const s = applyBase64Padding(normalized, true);
+        decoded = Uint8Array.from(Buffer.from(s, "base64"));
+        if (validatePadding) warnings.push("base64_raw does not support padding validation");
+        break;
+      }
+      case "hex": {
+        const s = normalized;
+        if (onError === "strict") {
+          if (!/^[0-9a-fA-F]*$/.test(s) || s.length % 2 !== 0) {
+            throw new Error("Invalid hex input");
+          }
+        }
+        decoded = Uint8Array.from(Buffer.from(s, "hex"));
+        break;
+      }
+      case "base32":
+      case "base32hex": {
+        decoded = decodeBase32(normalized, format, {
+          ignoreWhitespace,
+          validatePadding
+        });
+        break;
+      }
+      case "utf-8": {
+        decoded = new TextEncoder().encode(typeof input === "string" ? input : inputStr);
+        break;
+      }
+      case "utf-16le": {
+        decoded = Uint8Array.from(
+          Buffer.from(typeof input === "string" ? input : inputStr, "utf16le")
+        );
+        break;
+      }
+      case "utf-16be": {
+        const buf = Buffer.from(typeof input === "string" ? input : inputStr, "utf16le");
+        for (let i = 0; i + 1 < buf.length; i += 2) {
+          const a = buf[i];
+          buf[i] = buf[i + 1];
+          buf[i + 1] = a;
+        }
+        decoded = Uint8Array.from(buf);
+        break;
+      }
+      case "iso-8859-1": {
+        decoded = Uint8Array.from(
+          Buffer.from(typeof input === "string" ? input : inputStr, "latin1")
+        );
+        break;
+      }
+      case "ascii": {
+        decoded = Uint8Array.from(
+          Buffer.from(typeof input === "string" ? input : inputStr, "ascii")
+        );
+        break;
+      }
+      case "cp1252": {
+        throw new FulencodeError({
+          code: "UNSUPPORTED_FORMAT",
+          message: "cp1252 is not implemented in tsfulmen yet",
+          operation: "decode",
+          inputFormat: format
+        });
+      }
+      default: {
+        throw new FulencodeError({
+          code: "UNSUPPORTED_FORMAT",
+          message: `Unsupported decoding format: ${format}`,
+          operation: "decode",
+          inputFormat: format
+        });
+      }
+    }
+  } catch (err) {
+    if (err instanceof FulencodeError) throw err;
+    throw new FulencodeError({
+      code: "DECODE_FAILED",
+      message: err.message,
+      operation: "decode",
+      inputFormat: format,
+      cause: err
+    });
+  }
+  if (decoded.length > maxDecodedSize) {
+    throw new FulencodeError({
+      code: "OUTPUT_TOO_LARGE",
+      message: `Decoded output exceeds maxDecodedSize (${maxDecodedSize})`,
+      operation: "decode",
+      inputFormat: format,
+      details: { maxDecodedSize, outputSize: decoded.length }
+    });
+  }
+  const checksum = await computeChecksumIfRequested(decoded, options.computeChecksum);
+  return {
+    data: decoded,
+    format,
+    inputSize: typeof input === "string" ? Buffer.byteLength(input, "utf8") : input.length,
+    outputSize: decoded.length,
+    warnings,
+    correctionsApplied,
+    ...checksum
+  };
+}
+
+// src/fulencode/index.ts
+var VERSION = "0.1.0";
+var fulencode = {
+  encode,
+  decode
+};
+
+export { EncodingFormat, FulencodeError, VERSION, decode, encode, fulencode };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map