@fulmenhq/tsfulmen 0.3.3 → 0.4.0

package/dist/fulhash/index.js

@@ -1,613 +1,5 @@
-import { crc32, xxhash128, createXXHash128, createCRC32 } 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 || {});
-  }
-});
-
-// src/fulhash/errors.ts
-var FulHashError, UnsupportedAlgorithmError, InvalidChecksumError, InvalidChecksumFormatError, DigestStateError;
-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);
-      }
-    };
-    DigestStateError = class _DigestStateError extends FulHashError {
-      constructor(operation) {
-        super(`Cannot ${operation}: digest already finalized. Call reset() to reuse hasher.`);
-        this.name = "DigestStateError";
-        Object.setPrototypeOf(this, _DigestStateError.prototype);
-      }
-    };
-  }
-});
-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);
-}
-async function createHasher() {
-  const hasher = await createCRC32();
-  return hasher;
-}
-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);
-}
-async function createHasher2() {
-  const hasher = await createCRC32(CRC32C_POLYNOMIAL);
-  return hasher;
-}
-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"() {
-  }
-});
-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/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/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/index.ts
-init_types();
-
-// src/fulhash/convenience.ts
-init_digest();
-
-// src/fulhash/stream.ts
-init_types();
-init_crc32();
-init_crc32c();
-init_digest();
-init_errors();
-
-// src/fulhash/wasm-loader.ts
-init_errors();
-var isWasmReady = false;
-var initPromise = null;
-async function initializeWasm() {
-  if (isWasmReady) {
-    return;
-  }
-  if (initPromise) {
-    return initPromise;
-  }
-  initPromise = createXXHash128().then(() => {
-    isWasmReady = true;
-  }).catch((error) => {
-    initPromise = null;
-    throw new FulHashError(`Failed to initialize hash-wasm XXH3-128 module: ${error.message}`);
-  });
-  return initPromise;
-}
-async function createHasher3() {
-  if (!isWasmReady) {
-    throw new FulHashError("WASM not initialized. Call initializeWasm() first.");
-  }
-  return createXXHash128();
-}
-
-// src/fulhash/stream.ts
-function intToBytes(crc) {
-  const bytes = new Uint8Array(4);
-  const unsigned = crc >>> 0;
-  bytes[0] = unsigned >>> 24 & 255;
-  bytes[1] = unsigned >>> 16 & 255;
-  bytes[2] = unsigned >>> 8 & 255;
-  bytes[3] = unsigned & 255;
-  return bytes;
-}
-var BaseStreamHasher = class {
-  state = "initial" /* INITIAL */;
-  algorithm;
-  constructor(algorithm) {
-    this.algorithm = algorithm;
-  }
-  ensureNotFinalized() {
-    if (this.state === "finalized" /* FINALIZED */) {
-      throw new DigestStateError("Cannot update after digest(). Call reset() to reuse hasher.");
-    }
-  }
-  ensureUpdating() {
-    if (this.state !== "updating" /* UPDATING */ && this.state !== "initial" /* INITIAL */) {
-      throw new DigestStateError("Invalid state for digest(). Hasher may have been finalized.");
-    }
-  }
-  markUpdating() {
-    this.state = "updating" /* UPDATING */;
-  }
-  markFinalized() {
-    this.state = "finalized" /* FINALIZED */;
-  }
-  markInitial() {
-    this.state = "initial" /* INITIAL */;
-  }
-};
-var SHA256StreamHasher = class extends BaseStreamHasher {
-  hasher;
-  constructor() {
-    super("sha256" /* SHA256 */);
-    this.hasher = createHash("sha256");
-  }
-  update(data) {
-    this.ensureNotFinalized();
-    this.markUpdating();
-    if (typeof data === "string") {
-      this.hasher.update(data, "utf8");
-    } else {
-      this.hasher.update(data);
-    }
-    return this;
-  }
-  digest() {
-    this.ensureUpdating();
-    this.markFinalized();
-    const bytes = new Uint8Array(this.hasher.digest());
-    return new Digest(this.algorithm, bytes);
-  }
-  reset() {
-    this.hasher = createHash("sha256");
-    this.markInitial();
-    return this;
-  }
-};
-var XXH3StreamHasher = class extends BaseStreamHasher {
-  hasher;
-  constructor(hasher) {
-    super("xxh3-128" /* XXH3_128 */);
-    this.hasher = hasher;
-    this.hasher.init();
-  }
-  update(data) {
-    this.ensureNotFinalized();
-    this.markUpdating();
-    if (typeof data === "string") {
-      const encoder = new TextEncoder();
-      this.hasher.update(encoder.encode(data));
-    } else {
-      this.hasher.update(data);
-    }
-    return this;
-  }
-  digest() {
-    this.ensureUpdating();
-    this.markFinalized();
-    const bytes = this.hasher.digest("binary");
-    return new Digest(this.algorithm, bytes);
-  }
-  reset() {
-    this.hasher.init();
-    this.markInitial();
-    return this;
-  }
-};
-var CRC32StreamHasher = class extends BaseStreamHasher {
-  hasher = null;
-  constructor() {
-    super("crc32" /* CRC32 */);
-  }
-  async init() {
-    this.hasher = await createHasher();
-    this.hasher.init();
-  }
-  update(data) {
-    this.ensureNotFinalized();
-    this.markUpdating();
-    if (!this.hasher) {
-      throw new Error("Hasher not initialized");
-    }
-    if (typeof data === "string") {
-      const encoder = new TextEncoder();
-      this.hasher.update(encoder.encode(data));
-    } else {
-      this.hasher.update(data);
-    }
-    return this;
-  }
-  digest() {
-    this.ensureUpdating();
-    this.markFinalized();
-    if (!this.hasher) throw new Error("Hasher not initialized");
-    const hex = this.hasher.digest();
-    const bytes = intToBytes(parseInt(hex, 16));
-    return new Digest(this.algorithm, bytes);
-  }
-  reset() {
-    if (!this.hasher) throw new Error("Hasher not initialized");
-    this.hasher.init();
-    this.markInitial();
-    return this;
-  }
-};
-var CRC32CStreamHasher = class extends BaseStreamHasher {
-  hasher = null;
-  constructor() {
-    super("crc32c" /* CRC32C */);
-  }
-  async init() {
-    this.hasher = await createHasher2();
-    this.hasher.init();
-  }
-  update(data) {
-    this.ensureNotFinalized();
-    this.markUpdating();
-    if (!this.hasher) throw new Error("Hasher not initialized");
-    if (typeof data === "string") {
-      const encoder = new TextEncoder();
-      this.hasher.update(encoder.encode(data));
-    } else {
-      this.hasher.update(data);
-    }
-    return this;
-  }
-  digest() {
-    this.ensureUpdating();
-    this.markFinalized();
-    if (!this.hasher) throw new Error("Hasher not initialized");
-    const hex = this.hasher.digest();
-    const bytes = intToBytes(parseInt(hex, 16));
-    return new Digest(this.algorithm, bytes);
-  }
-  reset() {
-    if (!this.hasher) throw new Error("Hasher not initialized");
-    this.hasher.init();
-    this.markInitial();
-    return this;
-  }
-};
-async function createStreamHasher(options = {}) {
-  const algorithm = options.algorithm ?? "xxh3-128" /* XXH3_128 */;
-  switch (algorithm) {
-    case "sha256" /* SHA256 */:
-      return new SHA256StreamHasher();
-    case "xxh3-128" /* XXH3_128 */: {
-      await initializeWasm();
-      const wasmHasher = await createHasher3();
-      return new XXH3StreamHasher(wasmHasher);
-    }
-    case "crc32" /* CRC32 */: {
-      const hasher = new CRC32StreamHasher();
-      await hasher.init();
-      return hasher;
-    }
-    case "crc32c" /* CRC32C */: {
-      const hasher = new CRC32CStreamHasher();
-      await hasher.init();
-      return hasher;
-    }
-    default:
-      throw new UnsupportedAlgorithmError(algorithm, Object.values(Algorithm));
-  }
-}
-
-// src/fulhash/convenience.ts
-async function multiHash(input, algorithms, encoding = "utf8") {
-  const uniqueAlgorithms = [...new Set(algorithms)];
-  const hashers = await Promise.all(
-    uniqueAlgorithms.map((algo) => createStreamHasher({ algorithm: algo }))
-  );
-  if (typeof input === "string") {
-    if (encoding !== "utf8") {
-      const buf = Buffer.from(input, encoding);
-      for (const hasher of hashers) {
-        hasher.update(buf);
-      }
-    } else {
-      for (const hasher of hashers) {
-        hasher.update(input);
-      }
-    }
-  } else if (input instanceof Uint8Array) {
-    for (const hasher of hashers) {
-      hasher.update(input);
-    }
-  } else {
-    for await (const chunk of input) {
-      for (const hasher of hashers) {
-        hasher.update(chunk);
-      }
-    }
-  }
-  const result = {};
-  for (let i = 0; i < uniqueAlgorithms.length; i++) {
-    result[uniqueAlgorithms[i]] = hashers[i].digest();
-  }
-  return result;
-}
-async function verify(input, checksum, encoding = "utf8") {
-  const expected = Digest.parse(checksum);
-  const result = await multiHash(input, [expected.algorithm], encoding);
-  const actual = result[expected.algorithm];
-  if (!actual) return false;
-  return actual.algorithm === expected.algorithm && actual.hex === expected.hex;
-}
-
-// src/fulhash/index.ts
-init_digest();
-init_errors();
-init_hash();
-var VERSION = "1.0.0";
-
-export { Algorithm, Digest, DigestStateError, FulHashError, InvalidChecksumError, InvalidChecksumFormatError, UnsupportedAlgorithmError, VERSION, createStreamHasher, hash, hashBytes5 as hashBytes, hashString5 as hashString, multiHash, verify };
+export { VERSION, createStreamHasher, multiHash, verify } from '../chunk-WSMVLWLB.js';
+export { Algorithm, Digest, DigestStateError, FulHashError, InvalidChecksumError, InvalidChecksumFormatError, UnsupportedAlgorithmError, hash, hashBytes, hashString } from '../chunk-OHE2AOH4.js';
+import '../chunk-UP2VWCW5.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map