genome 1.0.0 → 1.0.3

package/dist/index.d.ts

@@ -1,272 +0,0 @@
-/**
- * @fileoverview Deterministic structure ID generation for JavaScript objects using hierarchical hashing and collision-resistant algorithms
- * @module @synpatico/genome
- */
-/**
- * Global cache of property names to their deterministic hash values.
- * Used to ensure consistent bit generation across different executions.
- */
-export declare const GLOBAL_KEY_MAP: Map<string, bigint>;
-/**
- * Tracks collision counts for structure signatures to handle hash conflicts.
- * Maps structure signatures to their collision counter values.
- */
-export declare const STRUCTURE_HASH_COUNTER: Map<string, number>;
-/**
- * WeakMap cache for object-to-structure-ID mappings.
- * Automatically garbage collected when objects are no longer referenced.
- */
-export declare let OBJECT_ID_CACHE: WeakMap<object, string>;
-/**
- * WeakMap cache for object-to-signature mappings.
- * Stores the signature portion (excluding L0 level) for collision detection.
- */
-export declare let OBJECT_SIGNATURE_CACHE: WeakMap<object, string>;
-/**
- * WeakMap cache for complete structure information including metadata.
- * Stores comprehensive structure analysis results for performance optimization.
- */
-export declare let STRUCTURE_INFO_CACHE: WeakMap<object, {
-    id: string;
-    levels: number;
-    collisionCount: number;
-}>;
-/**
- * Configuration options for structure ID generation
- */
-export interface StructureIdConfig {
-    /** Whether to generate new IDs on collision (default: false) */
-    newIdOnCollision?: boolean;
-    /**
-     * When true, arrays with different lengths but the same element shapes
-     * will produce the same structure ID. Distinct element shapes within
-     * an array are still differentiated. (default: false)
-     *
-     * @example
-     * // Same ID:
-     * generateStructureId({ items: [1, 2, 3] }, { ignoreArrayLength: true })
-     * generateStructureId({ items: [1, 2] },    { ignoreArrayLength: true })
-     *
-     * // Different ID (different element shapes):
-     * generateStructureId({ items: [1, 'a'] },         { ignoreArrayLength: true })
-     * generateStructureId({ items: [{ id: 1 }, 'a'] }, { ignoreArrayLength: true })
-     */
-    ignoreArrayLength?: boolean;
-}
-/**
- * Sets the global configuration for structure ID generation
- * @param config - The configuration options to apply
- * @example
- * ```javascript
- * setStructureIdConfig({ newIdOnCollision: true });
- * ```
- */
-export declare function setStructureIdConfig(config: StructureIdConfig): void;
-/**
- * Gets the current global configuration for structure ID generation
- * @returns A copy of the current configuration
- */
-export declare function getStructureIdConfig(): StructureIdConfig;
-/**
- * Generates a unique, deterministic structure ID for any JavaScript value.
- * The ID captures the complete shape and type information hierarchically.
- *
- * @param obj - The value to generate a structure ID for
- * @param config - Optional configuration to override global settings
- * @returns A hierarchical structure ID in format "L0:hash-L1:hash-L2:hash..."
- *
- * @example
- * ```javascript
- * const obj = { users: [{ id: 1, name: "John" }] };
- * const id = generateStructureId(obj);
- * // Returns: "L0:384729-L1:8374629-L2:9283746"
- * ```
- *
- * @example
- * ```javascript
- * // Empty objects and arrays have special IDs
- * generateStructureId({});  // Returns: "{}"
- * generateStructureId([]);  // Returns: "[]"
- * ```
- */
-export declare const generateStructureId: (obj: unknown, config?: StructureIdConfig) => string;
-/**
- * Gets the structure signature (without L0 collision counter) for an object.
- * This signature represents the object's shape and is used for collision detection.
- *
- * @param obj - The object to get a signature for
- * @returns A signature string like "L1:hash-L2:hash" or "type:primitive" for primitives
- *
- * @example
- * ```javascript
- * const sig1 = getStructureSignature({ id: 1, name: "John" });
- * const sig2 = getStructureSignature({ id: 2, name: "Jane" });
- * console.log(sig1 === sig2); // true (same structure)
- * ```
- */
-export declare function getStructureSignature(obj: unknown): string;
-/**
- * Registers a structure with a specific collision count.
- * Used to pre-populate collision counters for known structures.
- *
- * @param obj - The object whose structure to register
- * @param collisionCount - The collision count to set for this structure
- *
- * @example
- * ```javascript
- * const template = { id: 0, name: "" };
- * registerStructure(template, 5); // Pre-register with collision count 5
- * ```
- */
-export declare function registerStructure(obj: unknown, collisionCount: number): void;
-/**
- * Batch registers multiple structures with their collision counts.
- * Useful for pre-populating the collision counter from saved state.
- *
- * @param registrations - Array of structure-count pairs to register
- *
- * @example
- * ```javascript
- * registerStructures([
- *   { structure: { id: 0 }, count: 3 },
- *   { structure: { name: "" }, count: 1 }
- * ]);
- * ```
- */
-export declare function registerStructures(registrations: Array<{
-    structure: unknown;
-    count: number;
-}>): void;
-/**
- * Structure registration data for importing/exporting collision state
- */
-export interface StructureRegistration {
-    /** The structure signature (without L0) */
-    signature: string;
-    /** The collision counter value */
-    count: number;
-}
-/**
- * Registers structure signatures directly without needing object instances.
- * Useful for importing collision state from external sources.
- *
- * @param signatures - Array of signature-count pairs to register
- *
- * @example
- * ```javascript
- * registerStructureSignatures([
- *   { signature: "L1:123-L2:456", count: 2 },
- *   { signature: "L1:789-L2:012", count: 0 }
- * ]);
- * ```
- */
-export declare function registerStructureSignatures(signatures: Array<StructureRegistration>): void;
-/**
- * Gets comprehensive structure information including ID, depth levels, and collision count.
- * Caches results for performance optimization.
- *
- * @param obj - The object to analyze
- * @param config - Optional configuration to override global settings
- * @returns Structure information object
- *
- * @example
- * ```javascript
- * const info = getStructureInfo({ users: [{ id: 1, name: "John" }] });
- * console.log(info);
- * // {
- * //   id: "L0:384729-L1:8374629-L2:9283746",
- * //   levels: 3,
- * //   collisionCount: 0
- * // }
- * ```
- */
-export declare function getStructureInfo(obj: unknown, config?: StructureIdConfig): {
-    id: string;
-    levels: number;
-    collisionCount: number;
-};
-/**
- * Resets all global state including caches and collision counters.
- * Useful for testing or when you need to start fresh.
- *
- * @example
- * ```javascript
- * resetState(); // Clear all caches and counters
- * ```
- */
-export declare function resetState(): void;
-/**
- * Serializable state of the structure ID system
- */
-export interface StructureState {
-    /** Map of keys to their hash values */
-    keyMap: Record<string, string>;
-    /** Map of structure signatures to collision counts */
-    collisionCounters: Record<string, number>;
-}
-/**
- * Exports the current state of the structure ID system.
- * Useful for persisting state across sessions or sharing between environments.
- *
- * @returns The current state including key mappings and collision counters
- *
- * @example
- * ```javascript
- * const state = exportStructureState();
- * localStorage.setItem('genomeState', JSON.stringify(state));
- * ```
- */
-export declare function exportStructureState(): StructureState;
-/**
- * Imports a previously exported structure state.
- * Resets current state before importing to ensure clean slate.
- *
- * @param state - The state to import
- *
- * @example
- * ```javascript
- * const savedState = JSON.parse(localStorage.getItem('genomeState'));
- * importStructureState(savedState);
- * ```
- */
-export declare function importStructureState(state: StructureState): void;
-/**
- * Generates a compact, fixed-length structure ID using SHA-256 hashing.
- * Useful when you need consistent-length IDs regardless of object depth.
- *
- * @param obj - The object to generate a compact ID for
- * @param config - Optional configuration to override global settings
- * @returns A 64-character hexadecimal hash string
- *
- * @example
- * ```javascript
- * const compactId = getCompactId({ users: [{ id: 1, name: "John" }] });
- * console.log(compactId); // "a3f2b8c9d4e5f6a7b8c9d0e1f2a3b4c5..."
- * ```
- */
-export declare const getCompactId: (obj: unknown, config?: StructureIdConfig) => string;
-/**
- * Gets structure information with a compact ID format.
- * Combines the comprehensive analysis of getStructureInfo with compact ID generation.
- *
- * @param obj - The object to analyze
- * @param config - Optional configuration to override global settings
- * @returns Structure info with compact hash ID
- *
- * @example
- * ```javascript
- * const info = getCompactInfo({ users: [] });
- * console.log(info);
- * // {
- * //   id: "a3f2b8c9d4e5f6a7b8c9d0e1f2a3b4c5...",
- * //   levels: 2,
- * //   collisionCount: 0
- * // }
- * ```
- */
-export declare const getCompactInfo: (obj: unknown, config?: StructureIdConfig) => {
-    id: string;
-    levels: number;
-    collisionCount: number;
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqBH;;;GAGG;AACH,eAAO,MAAM,cAAc,qBAA4B,CAAA;AAEvD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,qBAA4B,CAAA;AAE/D;;;GAGG;AACH,eAAO,IAAI,eAAe,yBAAgC,CAAA;AAE1D;;;GAGG;AACH,eAAO,IAAI,sBAAsB,yBAAgC,CAAA;AAEjE;;;GAGG;AACH,eAAO,IAAI,oBAAoB;QAGzB,MAAM;YACF,MAAM;oBACE,MAAM;EAErB,CAAA;AA2BH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAWD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAEpE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CAExD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,OAAO,EAAE,SAAS,iBAAiB,KAAG,MAqM9E,CAAA;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAe1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAG5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CACjC,aAAa,EAAE,KAAK,CAAC;IACpB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACb,CAAC,GACA,IAAI,CAIN;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,IAAI,CAI1F;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,OAAO,EACZ,MAAM,CAAC,EAAE,iBAAiB,GACxB;IACF,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;CACtB,CAgDA;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAcjC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAerD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAkBhE;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,OAAO,EAAE,SAAS,iBAAiB,KAAG,MAIvE,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,GAC1B,KAAK,OAAO,EACZ,SAAS,iBAAiB,KACxB;IACF,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;CAOtB,CAAA"}

package/dist/index.js

@@ -1,405 +0,0 @@
-// src/hash.ts
-var hashFunction = {
-  MURMUR: murmurHash3,
-  XXHASH: xxHash32
-};
-var hash = (str, options) => {
-  if (options) {
-    if (options.custom !== void 0 && typeof options.custom === "function") {
-      return options.custom(str);
-    }
-    if (options.type) {
-      return options.type(str);
-    }
-  }
-  return hashFunction.XXHASH(str);
-};
-function murmurHash3(str) {
-  const seed = 0;
-  const c1 = 3432918353;
-  const c2 = 461845907;
-  const r1 = 15;
-  const r2 = 13;
-  const m = 5;
-  const n = 3864292196;
-  let hash2 = seed;
-  const data = new TextEncoder().encode(str);
-  const len = data.length;
-  const nblocks = Math.floor(len / 4);
-  for (let i = 0; i < nblocks; i++) {
-    let k2 = data[i * 4] | data[i * 4 + 1] << 8 | data[i * 4 + 2] << 16 | data[i * 4 + 3] << 24;
-    k2 = Math.imul(k2, c1);
-    k2 = k2 << r1 | k2 >>> 32 - r1;
-    k2 = Math.imul(k2, c2);
-    hash2 ^= k2;
-    hash2 = hash2 << r2 | hash2 >>> 32 - r2;
-    hash2 = Math.imul(hash2, m) + n;
-  }
-  let k = 0;
-  const remaining = len - nblocks * 4;
-  const offset = nblocks * 4;
-  if (remaining === 3) {
-    k ^= data[offset + 2] << 16;
-  }
-  if (remaining >= 2) {
-    k ^= data[offset + 1] << 8;
-  }
-  if (remaining >= 1) {
-    k ^= data[offset];
-    k = Math.imul(k, c1);
-    k = k << r1 | k >>> 32 - r1;
-    k = Math.imul(k, c2);
-    hash2 ^= k;
-  }
-  hash2 ^= len;
-  hash2 ^= hash2 >>> 16;
-  hash2 = Math.imul(hash2, 2246822507);
-  hash2 ^= hash2 >>> 13;
-  hash2 = Math.imul(hash2, 3266489909);
-  hash2 ^= hash2 >>> 16;
-  return (hash2 >>> 0).toString(16);
-}
-var PRIME32_1 = 2654435761;
-var PRIME32_2 = 2246822519;
-var PRIME32_3 = 3266489917;
-var PRIME32_4 = 668265263;
-var PRIME32_5 = 374761393;
-var encoder;
-function xxHash32(input, seed = 0) {
-  const buffer = typeof input === "string" ? (
-    // biome-ignore lint/suspicious/noAssignInExpressions: allow
-    (encoder ??= new TextEncoder()).encode(input)
-  ) : input;
-  const b = buffer;
-  let acc = seed + PRIME32_5 & 4294967295;
-  let offset = 0;
-  if (b.length >= 16) {
-    const accN = [
-      seed + PRIME32_1 + PRIME32_2 & 4294967295,
-      seed + PRIME32_2 & 4294967295,
-      seed + 0 & 4294967295,
-      seed - PRIME32_1 & 4294967295
-    ];
-    const b2 = buffer;
-    const limit2 = b2.length - 16;
-    let lane = 0;
-    for (offset = 0; (offset & 4294967280) <= limit2; offset += 4) {
-      const i = offset;
-      const laneN0 = b2[i + 0] + (b2[i + 1] << 8);
-      const laneN1 = b2[i + 2] + (b2[i + 3] << 8);
-      const laneNP = laneN0 * PRIME32_2 + (laneN1 * PRIME32_2 << 16);
-      let acc2 = accN[lane] + laneNP & 4294967295;
-      acc2 = acc2 << 13 | acc2 >>> 19;
-      const acc0 = acc2 & 65535;
-      const acc1 = acc2 >>> 16;
-      accN[lane] = acc0 * PRIME32_1 + (acc1 * PRIME32_1 << 16) & 4294967295;
-      lane = lane + 1 & 3;
-    }
-    acc = (accN[0] << 1 | accN[0] >>> 31) + (accN[1] << 7 | accN[1] >>> 25) + (accN[2] << 12 | accN[2] >>> 20) + (accN[3] << 18 | accN[3] >>> 14) & 4294967295;
-  }
-  acc = acc + buffer.length & 4294967295;
-  const limit = buffer.length - 4;
-  for (; offset <= limit; offset += 4) {
-    const i = offset;
-    const laneN0 = b[i + 0] + (b[i + 1] << 8);
-    const laneN1 = b[i + 2] + (b[i + 3] << 8);
-    const laneP = laneN0 * PRIME32_3 + (laneN1 * PRIME32_3 << 16);
-    acc = acc + laneP & 4294967295;
-    acc = acc << 17 | acc >>> 15;
-    acc = (acc & 65535) * PRIME32_4 + ((acc >>> 16) * PRIME32_4 << 16) & 4294967295;
-  }
-  for (; offset < b.length; ++offset) {
-    const lane = b[offset];
-    acc = acc + lane * PRIME32_5;
-    acc = acc << 11 | acc >>> 21;
-    acc = (acc & 65535) * PRIME32_1 + ((acc >>> 16) * PRIME32_1 << 16) & 4294967295;
-  }
-  acc = acc ^ acc >>> 15;
-  acc = ((acc & 65535) * PRIME32_2 & 4294967295) + ((acc >>> 16) * PRIME32_2 << 16);
-  acc = acc ^ acc >>> 13;
-  acc = ((acc & 65535) * PRIME32_3 & 4294967295) + ((acc >>> 16) * PRIME32_3 << 16);
-  acc = acc ^ acc >>> 16;
-  return acc < 0 ? (acc + 4294967296).toString(16) : acc.toString(16);
-}
-
-// src/index.ts
-var TYPE_BITS = {
-  root: BigInt(0),
-  number: BigInt(1),
-  string: BigInt(2),
-  boolean: BigInt(4),
-  bigint: BigInt(8),
-  null: BigInt(16),
-  undefined: BigInt(32),
-  symbol: BigInt(64),
-  object: BigInt(128),
-  array: BigInt(256)
-};
-var GLOBAL_KEY_MAP = /* @__PURE__ */ new Map();
-var STRUCTURE_HASH_COUNTER = /* @__PURE__ */ new Map();
-var OBJECT_ID_CACHE = /* @__PURE__ */ new WeakMap();
-var OBJECT_SIGNATURE_CACHE = /* @__PURE__ */ new WeakMap();
-var STRUCTURE_INFO_CACHE = /* @__PURE__ */ new WeakMap();
-var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
-var getBit = (key) => {
-  if (!GLOBAL_KEY_MAP.has(key)) {
-    const hashResult = xxHash32(key);
-    const deterministicBit = BigInt(`0x${hashResult}`);
-    GLOBAL_KEY_MAP.set(key, deterministicBit);
-  }
-  return GLOBAL_KEY_MAP.get(key);
-};
-var globalConfig = {
-  newIdOnCollision: false,
-  ignoreArrayLength: false
-};
-function setStructureIdConfig(config) {
-  globalConfig = { ...config };
-}
-function getStructureIdConfig() {
-  return { ...globalConfig };
-}
-var generateStructureId = (obj, config) => {
-  const emptyObj = isObject(obj) && Object.keys(obj).length === 0;
-  const emptyArr = Array.isArray(obj) && obj.length === 0;
-  if (emptyObj) return "{}";
-  if (emptyArr) return "[]";
-  const effectiveConfig = config ?? globalConfig;
-  const ignoreArrayLength = effectiveConfig.ignoreArrayLength ?? false;
-  if (typeof obj !== "object" || obj === null) {
-    return `L0:${TYPE_BITS[typeof obj] || BigInt(0)}-L1:${TYPE_BITS[typeof obj] || BigInt(0)}`;
-  }
-  if (!effectiveConfig?.newIdOnCollision && OBJECT_ID_CACHE.has(obj)) {
-    return OBJECT_ID_CACHE.get(obj);
-  }
-  const objectMap = /* @__PURE__ */ new Map();
-  const levelHashes = {};
-  const getType = (value) => {
-    if (value === null) return "null";
-    if (value === void 0) return "undefined";
-    if (Array.isArray(value)) return "array";
-    return typeof value;
-  };
-  const getObjectSignature = (obj2, path) => {
-    const type = Array.isArray(obj2) ? "array" : "object";
-    if (type === "object") {
-      const keys = Object.keys(obj2).sort().join(",");
-      return `${path.join(".")}.{${keys}}`;
-    }
-    return `${path.join(".")}.[${obj2.length}]`;
-  };
-  const processStructure = (value, level = 0, path = []) => {
-    if (!levelHashes[level]) {
-      levelHashes[level] = BigInt(1) << BigInt(level);
-    }
-    const type = getType(value);
-    levelHashes[level] += TYPE_BITS[type] || BigInt(0);
-    if (type !== "object" && type !== "array") {
-      return;
-    }
-    if (isObject(value) || Array.isArray(value)) {
-      const objValue = value;
-      const objSig = getObjectSignature(objValue, path);
-      if (objectMap.has(objValue)) {
-        const circularPath = objectMap.get(objValue);
-        levelHashes[level] += getBit(`circular:${circularPath}`);
-        return;
-      }
-      objectMap.set(objValue, objSig);
-      const objTypeBit = getBit(`type:${type}`);
-      levelHashes[level] += objTypeBit;
-      const isRootLevel = level === 0;
-      const isEmpty = isObject(value) && Object.keys(value).length === 0 || Array.isArray(value) && value.length === 0;
-      if (!isRootLevel || !isEmpty) {
-        if (type === "object") {
-          const objValue2 = value;
-          const keys = Object.keys(objValue2).sort();
-          let multiplier = BigInt(1);
-          for (const key of keys) {
-            const propType = getType(objValue2[key]);
-            const keyBit = getBit(key);
-            levelHashes[level] += keyBit * multiplier;
-            levelHashes[level] += (TYPE_BITS[propType] || BigInt(0)) * multiplier;
-            multiplier++;
-            processStructure(objValue2[key], level + 1, [...path, key]);
-          }
-        } else if (type === "array") {
-          const arrayValue = value;
-          if (!ignoreArrayLength) {
-            const lengthBit = getBit(`length:${arrayValue.length}`);
-            levelHashes[level] += lengthBit;
-            let multiplier = BigInt(1);
-            for (let i = 0; i < arrayValue.length; i++) {
-              const itemType = getType(arrayValue[i]);
-              const indexBit = getBit(`[${i}]`);
-              levelHashes[level] += indexBit * multiplier;
-              levelHashes[level] += (TYPE_BITS[itemType] || BigInt(0)) * multiplier;
-              multiplier++;
-              processStructure(arrayValue[i], level + 1, [...path, `[${i}]`]);
-            }
-          } else {
-            const seenShapes = /* @__PURE__ */ new Set();
-            for (const item of arrayValue) {
-              const itemType = getType(item);
-              const shapeKey = itemType === "object" || itemType === "array" ? getObjectSignature(item, [...path, "[*]"]) : `scalar:${itemType}`;
-              if (!seenShapes.has(shapeKey)) {
-                seenShapes.add(shapeKey);
-                levelHashes[level] += getBit(shapeKey);
-                processStructure(item, level + 1, [...path, "[*]"]);
-              }
-            }
-            levelHashes[level] += getBit("array:variadic");
-          }
-        }
-      }
-    }
-  };
-  processStructure(obj);
-  const structureLevels = Object.entries(levelHashes).filter(([level]) => Number(level) > 0).sort(([a], [b]) => Number(a) - Number(b)).map(([level, hash2]) => `L${level}:${hash2}`);
-  const structureSignature = structureLevels.join("-");
-  if (typeof obj === "object" && obj !== null) {
-    OBJECT_SIGNATURE_CACHE.set(obj, structureSignature);
-  }
-  const currentCount = STRUCTURE_HASH_COUNTER.get(structureSignature) ?? 0;
-  if (effectiveConfig?.newIdOnCollision) {
-    levelHashes[0] = BigInt(currentCount);
-    STRUCTURE_HASH_COUNTER.set(structureSignature, currentCount + 1);
-  }
-  const idParts = Object.entries(levelHashes).sort(([a], [b]) => Number(a) - Number(b)).map(([level, hash2]) => `L${level}:${hash2}`);
-  const finalId = idParts.join("-");
-  if (!effectiveConfig?.newIdOnCollision && typeof obj === "object" && obj !== null) {
-    OBJECT_ID_CACHE.set(obj, finalId);
-  }
-  if (typeof obj === "object" && obj !== null && STRUCTURE_INFO_CACHE.has(obj)) {
-    STRUCTURE_INFO_CACHE.delete(obj);
-  }
-  return finalId;
-};
-function calculateIdLevels(id) {
-  return id.split("-").length;
-}
-function getStructureSignature(obj) {
-  if (typeof obj !== "object" || obj === null) {
-    return `type:${typeof obj}`;
-  }
-  if (OBJECT_SIGNATURE_CACHE.has(obj)) {
-    return OBJECT_SIGNATURE_CACHE.get(obj);
-  }
-  const tempId = generateStructureId(obj, { newIdOnCollision: false });
-  const signature = tempId.split("-").slice(1).join("-");
-  OBJECT_SIGNATURE_CACHE.set(obj, signature);
-  return signature;
-}
-function registerStructure(obj, collisionCount) {
-  const signature = getStructureSignature(obj);
-  STRUCTURE_HASH_COUNTER.set(signature, collisionCount);
-}
-function registerStructures(registrations) {
-  for (const { structure, count } of registrations) {
-    registerStructure(structure, count);
-  }
-}
-function registerStructureSignatures(signatures) {
-  for (const { signature, count } of signatures) {
-    STRUCTURE_HASH_COUNTER.set(signature, count);
-  }
-}
-function getStructureInfo(obj, config) {
-  const effectiveConfig = config ?? globalConfig;
-  if (typeof obj !== "object" || obj === null) {
-    const id2 = generateStructureId(obj, { newIdOnCollision: false });
-    return {
-      id: id2,
-      levels: calculateIdLevels(id2),
-      collisionCount: 0
-    };
-  }
-  if (STRUCTURE_INFO_CACHE.has(obj)) {
-    return STRUCTURE_INFO_CACHE.get(obj);
-  }
-  const structureSignature = OBJECT_SIGNATURE_CACHE.has(obj) ? OBJECT_SIGNATURE_CACHE.get(obj) : generateStructureId(obj, { newIdOnCollision: false }).split("-").slice(1).join("-");
-  const collisionCount = STRUCTURE_HASH_COUNTER.get(structureSignature) || 0;
-  let id;
-  if (effectiveConfig.newIdOnCollision) {
-    const l0Hash = BigInt(collisionCount);
-    const l0Part = `L0:${l0Hash}`;
-    id = [l0Part, structureSignature].join("-");
-  } else {
-    id = OBJECT_ID_CACHE.has(obj) ? OBJECT_ID_CACHE.get(obj) : generateStructureId(obj, { newIdOnCollision: false });
-  }
-  const levels = calculateIdLevels(id);
-  const result = {
-    id,
-    levels,
-    collisionCount
-  };
-  STRUCTURE_INFO_CACHE.set(obj, result);
-  return result;
-}
-function resetState() {
-  GLOBAL_KEY_MAP.clear();
-  STRUCTURE_HASH_COUNTER.clear();
-  OBJECT_ID_CACHE = /* @__PURE__ */ new WeakMap();
-  OBJECT_SIGNATURE_CACHE = /* @__PURE__ */ new WeakMap();
-  STRUCTURE_INFO_CACHE = /* @__PURE__ */ new WeakMap();
-}
-function exportStructureState() {
-  const keyMap = {};
-  for (const [key, value] of GLOBAL_KEY_MAP.entries()) {
-    keyMap[key] = value.toString();
-  }
-  const collisionCounters = {};
-  for (const [signature, count] of STRUCTURE_HASH_COUNTER.entries()) {
-    collisionCounters[signature] = count;
-  }
-  return {
-    keyMap,
-    collisionCounters
-  };
-}
-function importStructureState(state) {
-  resetState();
-  for (const [key, valueStr] of Object.entries(state.keyMap)) {
-    GLOBAL_KEY_MAP.set(key, BigInt(valueStr));
-  }
-  for (const [signature, count] of Object.entries(state.collisionCounters)) {
-    STRUCTURE_HASH_COUNTER.set(signature, count);
-  }
-  let maxBit = BigInt(0);
-  for (const bitStr of Object.values(state.keyMap)) {
-    const bit = BigInt(bitStr);
-    if (bit > maxBit) {
-      maxBit = bit;
-    }
-  }
-}
-var getCompactId = (obj, config) => {
-  const fullId = generateStructureId(obj, config);
-  return hash(fullId);
-};
-var getCompactInfo = (obj, config) => {
-  const info = getStructureInfo(obj, config);
-  info.id = hash(info.id);
-  return info;
-};
-export {
-  GLOBAL_KEY_MAP,
-  OBJECT_ID_CACHE,
-  OBJECT_SIGNATURE_CACHE,
-  STRUCTURE_HASH_COUNTER,
-  STRUCTURE_INFO_CACHE,
-  exportStructureState,
-  generateStructureId,
-  getCompactId,
-  getCompactInfo,
-  getStructureIdConfig,
-  getStructureInfo,
-  getStructureSignature,
-  importStructureState,
-  registerStructure,
-  registerStructureSignatures,
-  registerStructures,
-  resetState,
-  setStructureIdConfig
-};
-//# sourceMappingURL=index.js.map