@fulmenhq/tsfulmen 0.3.3 → 0.4.0

package/dist/foundry/similarity/index.js

@@ -1,136 +1,5 @@
-import { substringSimilarity, jaro_winkler, damerau_levenshtein, osa_distance, levenshtein, normalize as normalize$1, score as score$1, suggest as suggest$1 } from '@3leaps/string-metrics-wasm';
-
-// src/foundry/similarity/distance.ts
-function distance(a, b, metric = "levenshtein") {
-  switch (metric) {
-    case "levenshtein":
-      return levenshtein(a, b);
-    case "damerau_osa":
-      return osa_distance(a, b);
-    case "damerau_unrestricted":
-      return damerau_levenshtein(a, b);
-    case "jaro_winkler":
-      return jaro_winkler(a, b);
-    case "substring":
-      return substringSimilarity(a, b).score;
-    default:
-      throw new Error(
-        `Invalid metric '${metric}': must be one of: levenshtein, damerau_osa, damerau_unrestricted, jaro_winkler, substring`
-      );
-  }
-}
-
-// src/foundry/errors.ts
-var FoundryCatalogError = class _FoundryCatalogError extends Error {
-  constructor(message, catalog, cause) {
-    super(message);
-    this.catalog = catalog;
-    this.cause = cause;
-    this.name = "FoundryCatalogError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _FoundryCatalogError);
-    }
-  }
-  static invalidSchema(catalog, details, cause) {
-    return new _FoundryCatalogError(
-      `Invalid schema in ${catalog} catalog: ${details}`,
-      catalog,
-      cause
-    );
-  }
-  static missingCatalog(catalog) {
-    return new _FoundryCatalogError(`Catalog ${catalog} not found or could not be loaded`, catalog);
-  }
-  static invalidPattern(patternId, details) {
-    return new _FoundryCatalogError(`Invalid pattern ${patternId}: ${details}`, "patterns");
-  }
-  static compilationError(patternId, details, cause) {
-    return new _FoundryCatalogError(
-      `Failed to compile pattern ${patternId}: ${details}`,
-      "patterns",
-      cause
-    );
-  }
-};
-
-// src/foundry/similarity/errors.ts
-var SimilarityError = class extends FoundryCatalogError {
-  constructor(message, cause) {
-    super(message, "similarity", cause);
-    this.name = "SimilarityError";
-  }
-};
-function toNormalizationLocale(locale) {
-  if (!locale) {
-    return void 0;
-  }
-  if (locale === "tr" || locale === "az" || locale === "lt") {
-    return locale;
-  }
-  return void 0;
-}
-function normalize(value, preset = "default", locale) {
-  if (typeof preset === "object") {
-    const targetPreset = preset.stripAccents ? "aggressive" : "default";
-    const targetLocale = toNormalizationLocale(preset.locale ?? locale);
-    return normalize$1(value, targetPreset, targetLocale);
-  }
-  return normalize$1(value, preset, toNormalizationLocale(locale));
-}
-function casefold(value, locale) {
-  if (locale === "tr") {
-    return value.toLocaleLowerCase("tr-TR");
-  }
-  return value.toLowerCase();
-}
-function stripAccents(value) {
-  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
-}
-function equalsIgnoreCase(a, b, options) {
-  return normalize(a, options) === normalize(b, options);
-}
-function score(a, b, metric = "levenshtein") {
-  if (metric === "substring") {
-    return substringSimilarity(a, b).score;
-  }
-  return score$1(a, b, metric);
-}
-var DEFAULT_MIN_SCORE = 0.6;
-var DEFAULT_MAX_SUGGESTIONS = 3;
-var DEFAULT_METRIC = "levenshtein";
-var DEFAULT_NORMALIZE_PRESET = "default";
-function suggest(input, candidates, options) {
-  const metric = options?.metric ?? DEFAULT_METRIC;
-  const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
-  const maxSuggestions = options?.maxSuggestions ?? DEFAULT_MAX_SUGGESTIONS;
-  let normalizePreset = options?.normalizePreset ?? DEFAULT_NORMALIZE_PRESET;
-  if (options?.normalize === false) {
-    normalizePreset = "none";
-  } else if (options?.normalize === true && !options?.normalizePreset) {
-    normalizePreset = "default";
-  }
-  const wasmOptions = {
-    metric,
-    normalizePreset,
-    minScore,
-    maxSuggestions,
-    preferPrefix: options?.preferPrefix,
-    jaroPrefixScale: options?.jaroPrefixScale,
-    jaroMaxPrefix: options?.jaroMaxPrefix
-  };
-  const results = suggest$1(input, candidates, wasmOptions);
-  return results.map((r) => ({
-    value: r.value,
-    score: r.score,
-    matchedRange: r.matchedRange,
-    reason: r.reason,
-    normalizedValue: r.normalizedValue
-  }));
-}
-
-// src/foundry/similarity/index.ts
-var VERSION = "2.0.0";
-
-export { SimilarityError, VERSION, casefold, distance, equalsIgnoreCase, normalize, score, stripAccents, suggest };
+export { SimilarityError, VERSION, casefold, distance, equalsIgnoreCase, normalize, score, stripAccents, suggest } from '../../chunk-LWAH2UG7.js';
+import '../../chunk-3HISR2XI.js';
+import '../../chunk-UP2VWCW5.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/foundry/similarity/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/foundry/similarity/distance.ts","../../../src/foundry/errors.ts","../../../src/foundry/similarity/errors.ts","../../../src/foundry/similarity/normalization.ts","../../../src/foundry/similarity/score.ts","../../../src/foundry/similarity/suggest.ts","../../../src/foundry/similarity/index.ts"],"names":["wasmNormalize","substringSimilarity","wasmScore","wasmSuggest"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Distance calculation with multiple metric support.\n *\n * Implements Crucible Foundry Similarity Standard v2.0.0 with WASM-backed metrics.\n *\n * @module foundry/similarity/distance\n */\n\nimport {\n  damerau_levenshtein,\n  jaro_winkler,\n  levenshtein,\n  osa_distance,\n  substringSimilarity,\n} from \"@3leaps/string-metrics-wasm\";\nimport type { MetricType } from \"./types.js\";\n\n/**\n * Calculate edit distance between two strings using specified metric.\n *\n * @param a - First string\n * @param b - Second string\n * @param metric - Distance metric (default: \"levenshtein\")\n * @returns Edit distance as non-negative integer (or similarity score for jaro_winkler/substring)\n *\n * @example\n * distance(\"kitten\", \"sitting\") // 3\n * distance(\"abcd\", \"abdc\", \"damerau_osa\") // 1\n * distance(\"CA\", \"ABC\", \"damerau_unrestricted\") // 2\n * distance(\"hello world\", \"world\", \"substring\") // 0.625 (as score, not distance)\n */\nexport function distance(a: string, b: string, metric: MetricType = \"levenshtein\"): number {\n  switch (metric) {\n    case \"levenshtein\":\n      return levenshtein(a, b);\n    case \"damerau_osa\":\n      return osa_distance(a, b);\n    case \"damerau_unrestricted\":\n      return damerau_levenshtein(a, b);\n    case \"jaro_winkler\":\n      return jaro_winkler(a, b);\n    case \"substring\":\n      // Returns similarity score (not distance) with longest common substring\n      return substringSimilarity(a, b).score;\n    default:\n      throw new Error(\n        `Invalid metric '${metric}': must be one of: levenshtein, damerau_osa, damerau_unrestricted, jaro_winkler, substring`,\n      );\n  }\n}\n","/**\n * Foundry module - Error handling\n *\n * Custom error classes for Foundry catalog operations with fail-fast validation.\n */\n\nexport class FoundryCatalogError extends Error {\n  constructor(\n    message: string,\n    public readonly catalog?: string,\n    public readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = \"FoundryCatalogError\";\n\n    // Maintain proper stack trace for V8\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, FoundryCatalogError);\n    }\n  }\n\n  static invalidSchema(catalog: string, details: string, cause?: Error): FoundryCatalogError {\n    return new FoundryCatalogError(\n      `Invalid schema in ${catalog} catalog: ${details}`,\n      catalog,\n      cause,\n    );\n  }\n\n  static missingCatalog(catalog: string): FoundryCatalogError {\n    return new FoundryCatalogError(`Catalog ${catalog} not found or could not be loaded`, catalog);\n  }\n\n  static invalidPattern(patternId: string, details: string): FoundryCatalogError {\n    return new FoundryCatalogError(`Invalid pattern ${patternId}: ${details}`, \"patterns\");\n  }\n\n  static compilationError(patternId: string, details: string, cause?: Error): FoundryCatalogError {\n    return new FoundryCatalogError(\n      `Failed to compile pattern ${patternId}: ${details}`,\n      \"patterns\",\n      cause,\n    );\n  }\n}\n","import { FoundryCatalogError } from \"../errors.js\";\n\nexport class SimilarityError extends FoundryCatalogError {\n  constructor(message: string, cause?: Error) {\n    super(message, \"similarity\", cause);\n    this.name = \"SimilarityError\";\n  }\n}\n","/**\n * Unicode-aware text normalization utilities.\n *\n * Implements Crucible Foundry Similarity Standard v2.0.0 with normalization presets.\n *\n * @module foundry/similarity/normalization\n */\n\nimport {\n  type NormalizationLocale,\n  type NormalizationPreset as WasmNormalizationPreset,\n  normalize as wasmNormalize,\n} from \"@3leaps/string-metrics-wasm\";\nimport type { NormalizationPreset, NormalizeOptions } from \"./types.js\";\n\nfunction toNormalizationLocale(locale?: string): NormalizationLocale | undefined {\n  if (!locale) {\n    return undefined;\n  }\n\n  if (locale === \"tr\" || locale === \"az\" || locale === \"lt\") {\n    return locale;\n  }\n\n  return undefined;\n}\n\n/**\n * Apply normalization preset to text.\n *\n * @param value - Text to normalize\n * @param preset - Normalization preset (\"none\" | \"minimal\" | \"default\" | \"aggressive\")\n * @param locale - Optional locale for locale-aware casefolding (e.g., \"tr\" for Turkish)\n * @returns Normalized text\n *\n * @example\n * normalize(\"  Café-Zürich!  \", \"aggressive\") // \"cafezurich\"\n * normalize(\"  Hello  \", \"minimal\") // \"Hello\"\n * normalize(\"İstanbul\", \"default\", \"tr\") // \"istanbul\"\n */\nexport function normalize(\n  value: string,\n  preset: NormalizationPreset | NormalizeOptions = \"default\",\n  locale?: string,\n): string {\n  // Handle legacy NormalizeOptions interface for backward compatibility\n  if (typeof preset === \"object\") {\n    // Map old options to preset and extract locale\n    const targetPreset = preset.stripAccents ? \"aggressive\" : \"default\";\n    const targetLocale = toNormalizationLocale(preset.locale ?? locale);\n    return wasmNormalize(value, targetPreset, targetLocale);\n  }\n\n  return wasmNormalize(value, preset as WasmNormalizationPreset, toNormalizationLocale(locale));\n}\n\n/**\n * Unicode-aware case folding.\n *\n * @param value - Text to casefold\n * @param locale - Optional locale (e.g., \"tr\" for Turkish)\n * @returns Lowercase text\n */\nexport function casefold(value: string, locale?: string): string {\n  if (locale === \"tr\") {\n    return value.toLocaleLowerCase(\"tr-TR\");\n  }\n  return value.toLowerCase();\n}\n\n/**\n * Strip diacritical marks from text.\n *\n * @param value - Text to process\n * @returns Text with accents removed\n */\nexport function stripAccents(value: string): string {\n  return value.normalize(\"NFD\").replace(/[\\u0300-\\u036f]/g, \"\");\n}\n\n/**\n * Compare strings ignoring case and optionally accents.\n *\n * @param a - First string\n * @param b - Second string\n * @param options - Normalization options\n * @returns True if strings are equal after normalization\n */\nexport function equalsIgnoreCase(a: string, b: string, options?: NormalizeOptions): boolean {\n  return normalize(a, options) === normalize(b, options);\n}\n","/**\n * Normalized similarity score with metric selection.\n *\n * Implements Crucible Foundry Similarity Standard v2.0.0.\n *\n * @module foundry/similarity/score\n */\n\nimport {\n  type SimilarityMetric,\n  substringSimilarity,\n  score as wasmScore,\n} from \"@3leaps/string-metrics-wasm\";\nimport type { MetricType } from \"./types.js\";\n\n/**\n * Calculate normalized similarity score between two strings.\n *\n * Returns a value between 0.0 (completely different) and 1.0 (identical).\n * For distance-based metrics: 1 - distance / max(len(a), len(b))\n * For jaro_winkler and substring: direct similarity score\n *\n * @param a - First string\n * @param b - Second string\n * @param metric - Similarity metric (default: \"levenshtein\")\n * @returns Similarity score in range [0.0, 1.0]\n *\n * @example\n * score(\"kitten\", \"sitting\") // 0.5714...\n * score(\"hello\", \"hallo\", \"jaro_winkler\") // 0.88\n * score(\"hello world\", \"world\", \"substring\") // 0.625\n */\nexport function score(a: string, b: string, metric: MetricType = \"levenshtein\"): number {\n  // Special case: substring uses different API to get proper longest common substring\n  if (metric === \"substring\") {\n    return substringSimilarity(a, b).score;\n  }\n\n  // All other metrics supported directly by WASM score function\n  return wasmScore(a, b, metric as SimilarityMetric);\n}\n","/**\n * Suggestion API with fuzzy matching and configurable metrics.\n *\n * Implements Crucible Foundry Similarity Standard v2.0.0.\n *\n * @module foundry/similarity/suggest\n */\n\nimport { type SuggestMetric, suggest as wasmSuggest } from \"@3leaps/string-metrics-wasm\";\nimport type { Suggestion, SuggestOptions } from \"./types.js\";\n\nconst DEFAULT_MIN_SCORE = 0.6;\nconst DEFAULT_MAX_SUGGESTIONS = 3;\nconst DEFAULT_METRIC = \"levenshtein\";\nconst DEFAULT_NORMALIZE_PRESET = \"default\";\n\n/**\n * Generate ranked suggestions from candidate list based on similarity.\n *\n * @param input - Input string to match against\n * @param candidates - List of candidate strings\n * @param options - Suggestion options (metric, thresholds, normalization)\n * @returns Array of suggestions sorted by score (descending)\n *\n * @example\n * suggest(\"docscrib\", [\"docscribe\", \"crucible\"], { metric: \"levenshtein\" })\n * // [{ value: \"docscribe\", score: 0.889, ... }]\n */\nexport function suggest(\n  input: string,\n  candidates: readonly string[],\n  options?: SuggestOptions,\n): Suggestion[] {\n  const metric = options?.metric ?? DEFAULT_METRIC;\n  const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;\n  const maxSuggestions = options?.maxSuggestions ?? DEFAULT_MAX_SUGGESTIONS;\n\n  // Handle legacy 'normalize' boolean option\n  let normalizePreset = options?.normalizePreset ?? DEFAULT_NORMALIZE_PRESET;\n  if (options?.normalize === false) {\n    normalizePreset = \"none\";\n  } else if (options?.normalize === true && !options?.normalizePreset) {\n    normalizePreset = \"default\";\n  }\n\n  // Pass metric name directly to WASM library (it handles \"substring\" correctly)\n  const wasmOptions = {\n    metric: metric as SuggestMetric,\n    normalizePreset,\n    minScore,\n    maxSuggestions,\n    preferPrefix: options?.preferPrefix,\n    jaroPrefixScale: options?.jaroPrefixScale,\n    jaroMaxPrefix: options?.jaroMaxPrefix,\n  };\n\n  const results = wasmSuggest(input, candidates as string[], wasmOptions);\n\n  // Map WASM results to our Suggestion interface\n  return results.map((r) => ({\n    value: r.value,\n    score: r.score,\n    matchedRange: r.matchedRange as [number, number] | undefined,\n    reason: r.reason,\n    normalizedValue: r.normalizedValue,\n  }));\n}\n","/**\n * Foundry similarity module - Text similarity and normalization utilities\n *\n * Implements the Crucible Foundry Text Similarity & Normalization Standard v2.0.0 (2025.10.3).\n *\n * @module foundry/similarity\n */\n\nexport const VERSION = \"2.0.0\";\n\nexport { distance } from \"./distance.js\";\nexport { SimilarityError } from \"./errors.js\";\nexport {\n  casefold,\n  equalsIgnoreCase,\n  normalize,\n  stripAccents,\n} from \"./normalization.js\";\nexport { score } from \"./score.js\";\nexport { suggest } from \"./suggest.js\";\n\nexport type {\n  MetricType,\n  NormalizationPreset,\n  NormalizeOptions,\n  Suggestion,\n  SuggestOptions,\n} from \"./types.js\";\n"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/fulencode/index.js

@@ -1,317 +1,5 @@
-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();
-  }
-});
+import { hashBytes } from '../chunk-OHE2AOH4.js';
+import '../chunk-UP2VWCW5.js';
 
 // src/fulencode/errors.ts
 var FulencodeError = class extends Error {
@@ -350,10 +38,6 @@ var EncodingFormat = {
   ASCII: "ascii"
 };
 
-// src/fulencode/fulencode.ts
-init_types();
-init_hash();
-
 // src/fulencode/base32.ts
 var RFC4648_BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
 var RFC4648_BASE32HEX_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
@@ -497,7 +181,7 @@ async function computeChecksumIfRequested(data, algorithm) {
       details: { algorithm }
     });
   }
-  const digest = await hashBytes5(data, {
+  const digest = await hashBytes(data, {
     algorithm: algorithm === "sha256" ? "sha256" /* SHA256 */ : "xxh3-128" /* XXH3_128 */
   });
   return { checksum: digest.toString(), checksumAlgorithm: algorithm };