@tanstack/db-ivm 0.1.2 → 0.1.3

package/dist/cjs/hashIndex.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _inner;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("./utils.cjs");
+const hash = require("./hashing/hash.cjs");
+class HashIndex {
+  constructor() {
+    __privateAdd(this, _inner);
+    __privateSet(this, _inner, new utils.DefaultMap(
+      () => new utils.DefaultMap(() => [void 0, 0])
+    ));
+  }
+  toString(indent = false) {
+    return `HashIndex(${JSON.stringify(
+      [...__privateGet(this, _inner)].map(([k, valueMap]) => [k, [...valueMap]]),
+      void 0,
+      indent ? 2 : void 0
+    )})`;
+  }
+  get(key) {
+    const valueMap = __privateGet(this, _inner).get(key);
+    return [...valueMap.values()];
+  }
+  getMultiplicity(key, value) {
+    const valueMap = __privateGet(this, _inner).get(key);
+    const valueHash = hash.hash(value);
+    const [, multiplicity] = valueMap.get(valueHash);
+    return multiplicity;
+  }
+  entries() {
+    return __privateGet(this, _inner).entries();
+  }
+  *entriesIterator() {
+    for (const [key, valueMap] of __privateGet(this, _inner).entries()) {
+      for (const [_valueHash, [value, multiplicity]] of valueMap.entries()) {
+        yield [key, [value, multiplicity]];
+      }
+    }
+  }
+  has(key) {
+    return __privateGet(this, _inner).has(key);
+  }
+  delete(key) {
+    __privateGet(this, _inner).delete(key);
+  }
+  get size() {
+    return __privateGet(this, _inner).size;
+  }
+  /**
+   * Adds a value to the index and does not return anything
+   * except if the addition caused the value to be removed
+   * and the key to be left with only a single value.
+   * In that case, we return the single remaining value.
+   */
+  addValue(key, value) {
+    const [val, multiplicity] = value;
+    const valueMap = __privateGet(this, _inner).get(key);
+    const valueHash = hash.hash(val);
+    const [, existingMultiplicity] = valueMap.get(valueHash);
+    const newMultiplicity = existingMultiplicity + multiplicity;
+    if (multiplicity !== 0) {
+      if (newMultiplicity === 0) {
+        valueMap.delete(valueHash);
+        if (valueMap.size === 1) {
+          return valueMap.entries().next().value[1];
+        }
+      } else {
+        valueMap.set(valueHash, [val, newMultiplicity]);
+      }
+    }
+    __privateGet(this, _inner).set(key, valueMap);
+  }
+}
+_inner = new WeakMap();
+exports.HashIndex = HashIndex;
+//# sourceMappingURL=hashIndex.cjs.map

package/dist/cjs/hashIndex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashIndex.cjs","sources":["../../src/hashIndex.ts"],"sourcesContent":["import { DefaultMap } from \"./utils.js\"\nimport { hash } from \"./hashing/index.js\"\nimport type { Hash } from \"./hashing/index.js\"\n\n/**\n * A map from a difference collection trace's keys -> (value, multiplicities) that changed.\n * Used in operations like join and reduce where the operation needs to\n * exploit the key-value structure of the data to run efficiently.\n */\nexport class HashIndex<K, V> {\n  #inner: DefaultMap<K, DefaultMap<Hash, [V, number]>>\n\n  constructor() {\n    this.#inner = new DefaultMap<K, DefaultMap<Hash, [V, number]>>(\n      () => new DefaultMap<Hash, [V, number]>(() => [undefined as any as V, 0])\n    )\n    // #inner is as map of:\n    // {\n    //   [key]: {\n    //     [hash(value)]: [value, multiplicity]\n    //   }\n    // }\n  }\n\n  toString(indent = false): string {\n    return `HashIndex(${JSON.stringify(\n      [...this.#inner].map(([k, valueMap]) => [k, [...valueMap]]),\n      undefined,\n      indent ? 2 : undefined\n    )})`\n  }\n\n  get(key: K): Array<[V, number]> {\n    const valueMap = this.#inner.get(key)\n    return [...valueMap.values()]\n  }\n\n  getMultiplicity(key: K, value: V): number {\n    const valueMap = this.#inner.get(key)\n    const valueHash = hash(value)\n    const [, multiplicity] = valueMap.get(valueHash)\n    return multiplicity\n  }\n\n  entries() {\n    return this.#inner.entries()\n  }\n\n  *entriesIterator(): Generator<[K, [V, number]]> {\n    for (const [key, valueMap] of this.#inner.entries()) {\n      for (const [_valueHash, [value, multiplicity]] of valueMap.entries()) {\n        yield [key, [value, multiplicity]]\n      }\n    }\n  }\n\n  has(key: K): boolean {\n    return this.#inner.has(key)\n  }\n\n  delete(key: K): void {\n    this.#inner.delete(key)\n  }\n\n  get size(): number {\n    return this.#inner.size\n  }\n\n  /**\n   * Adds a value to the index and does not return anything\n   * except if the addition caused the value to be removed\n   * and the key to be left with only a single value.\n   * In that case, we return the single remaining value.\n   */\n  addValue(key: K, value: [V, number]): [V, number] | void {\n    const [val, multiplicity] = value\n    const valueMap = this.#inner.get(key)\n    const valueHash = hash(val)\n    const [, existingMultiplicity] = valueMap.get(valueHash)\n    const newMultiplicity = existingMultiplicity + multiplicity\n    if (multiplicity !== 0) {\n      if (newMultiplicity === 0) {\n        valueMap.delete(valueHash)\n        if (valueMap.size === 1) {\n          // Signal that the key only has a single remaining value\n          return valueMap.entries().next().value![1]\n        }\n      } else {\n        valueMap.set(valueHash, [val, newMultiplicity])\n      }\n    }\n    this.#inner.set(key, valueMap)\n  }\n}\n"],"names":["DefaultMap","hash"],"mappings":";;;;;;;;;;;;AASO,MAAM,UAAgB;AAAA,EAG3B,cAAc;AAFd;AAGE,uBAAK,QAAS,IAAIA,MAAAA;AAAAA,MAChB,MAAM,IAAIA,MAAAA,WAA8B,MAAM,CAAC,QAAuB,CAAC,CAAC;AAAA,IAAA;AAAA,EAQ5E;AAAA,EAEA,SAAS,SAAS,OAAe;AAC/B,WAAO,aAAa,KAAK;AAAA,MACvB,CAAC,GAAG,mBAAK,OAAM,EAAE,IAAI,CAAC,CAAC,GAAG,QAAQ,MAAM,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;AAAA,MAC1D;AAAA,MACA,SAAS,IAAI;AAAA,IAAA,CACd;AAAA,EACH;AAAA,EAEA,IAAI,KAA4B;AAC9B,UAAM,WAAW,mBAAK,QAAO,IAAI,GAAG;AACpC,WAAO,CAAC,GAAG,SAAS,QAAQ;AAAA,EAC9B;AAAA,EAEA,gBAAgB,KAAQ,OAAkB;AACxC,UAAM,WAAW,mBAAK,QAAO,IAAI,GAAG;AACpC,UAAM,YAAYC,KAAAA,KAAK,KAAK;AAC5B,UAAM,CAAA,EAAG,YAAY,IAAI,SAAS,IAAI,SAAS;AAC/C,WAAO;AAAA,EACT;AAAA,EAEA,UAAU;AACR,WAAO,mBAAK,QAAO,QAAA;AAAA,EACrB;AAAA,EAEA,CAAC,kBAA+C;AAC9C,eAAW,CAAC,KAAK,QAAQ,KAAK,mBAAK,QAAO,WAAW;AACnD,iBAAW,CAAC,YAAY,CAAC,OAAO,YAAY,CAAC,KAAK,SAAS,WAAW;AACpE,cAAM,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAAA,EAEA,IAAI,KAAiB;AACnB,WAAO,mBAAK,QAAO,IAAI,GAAG;AAAA,EAC5B;AAAA,EAEA,OAAO,KAAc;AACnB,uBAAK,QAAO,OAAO,GAAG;AAAA,EACxB;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,mBAAK,QAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,SAAS,KAAQ,OAAwC;AACvD,UAAM,CAAC,KAAK,YAAY,IAAI;AAC5B,UAAM,WAAW,mBAAK,QAAO,IAAI,GAAG;AACpC,UAAM,YAAYA,KAAAA,KAAK,GAAG;AAC1B,UAAM,CAAA,EAAG,oBAAoB,IAAI,SAAS,IAAI,SAAS;AACvD,UAAM,kBAAkB,uBAAuB;AAC/C,QAAI,iBAAiB,GAAG;AACtB,UAAI,oBAAoB,GAAG;AACzB,iBAAS,OAAO,SAAS;AACzB,YAAI,SAAS,SAAS,GAAG;AAEvB,iBAAO,SAAS,QAAA,EAAU,KAAA,EAAO,MAAO,CAAC;AAAA,QAC3C;AAAA,MACF,OAAO;AACL,iBAAS,IAAI,WAAW,CAAC,KAAK,eAAe,CAAC;AAAA,MAChD;AAAA,IACF;AACA,uBAAK,QAAO,IAAI,KAAK,QAAQ;AAAA,EAC/B;AACF;AAnFE;;"}

package/dist/cjs/hashIndex.d.cts

@@ -0,0 +1,25 @@
+import { DefaultMap } from './utils.js';
+/**
+ * A map from a difference collection trace's keys -> (value, multiplicities) that changed.
+ * Used in operations like join and reduce where the operation needs to
+ * exploit the key-value structure of the data to run efficiently.
+ */
+export declare class HashIndex<K, V> {
+    #private;
+    constructor();
+    toString(indent?: boolean): string;
+    get(key: K): Array<[V, number]>;
+    getMultiplicity(key: K, value: V): number;
+    entries(): MapIterator<[K, DefaultMap<number, [V, number]>]>;
+    entriesIterator(): Generator<[K, [V, number]]>;
+    has(key: K): boolean;
+    delete(key: K): void;
+    get size(): number;
+    /**
+     * Adds a value to the index and does not return anything
+     * except if the addition caused the value to be removed
+     * and the key to be left with only a single value.
+     * In that case, we return the single remaining value.
+     */
+    addValue(key: K, value: [V, number]): [V, number] | void;
+}

package/dist/cjs/hashing/hash.cjs

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const murmur = require("./murmur.cjs");
+const TRUE = murmur.randomHash();
+const FALSE = murmur.randomHash();
+const NULL = murmur.randomHash();
+const UNDEFINED = murmur.randomHash();
+const KEY = murmur.randomHash();
+const FUNCTIONS = murmur.randomHash();
+const DATE_MARKER = murmur.randomHash();
+const OBJECT_MARKER = murmur.randomHash();
+const ARRAY_MARKER = murmur.randomHash();
+const MAP_MARKER = murmur.randomHash();
+const SET_MARKER = murmur.randomHash();
+const hashCache = /* @__PURE__ */ new WeakMap();
+function hash(input) {
+  const hasher = new murmur.MurmurHashStream();
+  updateHasher(hasher, input);
+  return hasher.digest();
+}
+function hashObject(input) {
+  const cachedHash = hashCache.get(input);
+  if (cachedHash !== void 0) {
+    return cachedHash;
+  }
+  let valueHash;
+  if (input instanceof Date) {
+    valueHash = hashDate(input);
+  } else {
+    let plainObjectInput = input;
+    let marker = OBJECT_MARKER;
+    if (input instanceof Array) {
+      marker = ARRAY_MARKER;
+    }
+    if (input instanceof Map) {
+      marker = MAP_MARKER;
+      plainObjectInput = [...input.entries()];
+    }
+    if (input instanceof Set) {
+      marker = SET_MARKER;
+      plainObjectInput = [...input.entries()];
+    }
+    if (input instanceof Buffer || input instanceof Uint8Array || input instanceof File) {
+      return cachedReferenceHash(input);
+    }
+    valueHash = hashPlainObject(plainObjectInput, marker);
+  }
+  hashCache.set(input, valueHash);
+  return valueHash;
+}
+function hashDate(input) {
+  const hasher = new murmur.MurmurHashStream();
+  hasher.update(DATE_MARKER);
+  hasher.update(input.getTime());
+  return hasher.digest();
+}
+function hashPlainObject(input, marker) {
+  const hasher = new murmur.MurmurHashStream();
+  hasher.update(marker);
+  const keys = Object.keys(input);
+  keys.sort(keySort);
+  for (const key of keys) {
+    hasher.update(KEY);
+    hasher.update(key);
+    updateHasher(hasher, input[key]);
+  }
+  return hasher.digest();
+}
+function updateHasher(hasher, input) {
+  if (input === null) {
+    hasher.update(NULL);
+    return;
+  }
+  switch (typeof input) {
+    case `undefined`:
+      hasher.update(UNDEFINED);
+      return;
+    case `boolean`:
+      hasher.update(input ? TRUE : FALSE);
+      return;
+    case `number`:
+      hasher.update(isNaN(input) ? NaN : input === 0 ? 0 : input);
+      return;
+    case `bigint`:
+    case `string`:
+    case `symbol`:
+      hasher.update(input);
+      return;
+    case `object`:
+      hasher.update(getCachedHash(input));
+      return;
+    case `function`:
+      hasher.update(cachedReferenceHash(input));
+      return;
+    default:
+      console.warn(
+        `Ignored input during hashing because it is of type ${typeof input} which is not supported`
+      );
+  }
+}
+function getCachedHash(input) {
+  let valueHash = hashCache.get(input);
+  if (valueHash === void 0) {
+    valueHash = hashObject(input);
+  }
+  return valueHash;
+}
+let nextRefId = 1;
+function cachedReferenceHash(fn) {
+  let valueHash = hashCache.get(fn);
+  if (valueHash === void 0) {
+    valueHash = nextRefId ^ FUNCTIONS;
+    nextRefId++;
+    hashCache.set(fn, valueHash);
+  }
+  return valueHash;
+}
+function keySort(a, b) {
+  return a.localeCompare(b);
+}
+exports.hash = hash;
+//# sourceMappingURL=hash.cjs.map

package/dist/cjs/hashing/hash.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.cjs","sources":["../../../src/hashing/hash.ts"],"sourcesContent":["import { MurmurHashStream, randomHash } from \"./murmur.js\"\nimport type { Hasher } from \"./murmur.js\"\n\n/*\n * Implementation of structural hashing based on the Composites polyfill implementation:\n * https://github.com/tc39/proposal-composites\n */\n\nconst TRUE = randomHash()\nconst FALSE = randomHash()\nconst NULL = randomHash()\nconst UNDEFINED = randomHash()\nconst KEY = randomHash()\nconst FUNCTIONS = randomHash()\nconst DATE_MARKER = randomHash()\nconst OBJECT_MARKER = randomHash()\nconst ARRAY_MARKER = randomHash()\nconst MAP_MARKER = randomHash()\nconst SET_MARKER = randomHash()\n\nconst hashCache = new WeakMap<object, number>()\n\nexport function hash(input: any): number {\n  const hasher = new MurmurHashStream()\n  updateHasher(hasher, input)\n  return hasher.digest()\n}\n\nfunction hashObject(input: object): number {\n  const cachedHash = hashCache.get(input)\n  if (cachedHash !== undefined) {\n    return cachedHash\n  }\n\n  let valueHash: number | undefined\n  if (input instanceof Date) {\n    valueHash = hashDate(input)\n  } else {\n    let plainObjectInput = input\n    let marker = OBJECT_MARKER\n\n    if (input instanceof Array) {\n      marker = ARRAY_MARKER\n    }\n\n    if (input instanceof Map) {\n      marker = MAP_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    if (input instanceof Set) {\n      marker = SET_MARKER\n      plainObjectInput = [...input.entries()]\n    }\n\n    if (\n      input instanceof Buffer ||\n      input instanceof Uint8Array ||\n      input instanceof File\n    ) {\n      // Deeply hashing these objects would be too costly\n      // but we also don't want to ignore them\n      // so we track them by reference and cache them in a weak map\n      return cachedReferenceHash(input)\n    }\n\n    valueHash = hashPlainObject(plainObjectInput, marker)\n  }\n\n  hashCache.set(input, valueHash)\n  return valueHash\n}\n\nfunction hashDate(input: Date): number {\n  const hasher = new MurmurHashStream()\n  hasher.update(DATE_MARKER)\n  hasher.update(input.getTime())\n  return hasher.digest()\n}\n\nfunction hashPlainObject(input: object, marker: number): number {\n  const hasher = new MurmurHashStream()\n\n  // Mark the type of the input\n  hasher.update(marker)\n  const keys = Object.keys(input)\n  keys.sort(keySort)\n  for (const key of keys) {\n    hasher.update(KEY)\n    hasher.update(key)\n    updateHasher(hasher, input[key as keyof typeof input])\n  }\n\n  return hasher.digest()\n}\n\nfunction updateHasher(hasher: Hasher, input: unknown): void {\n  if (input === null) {\n    hasher.update(NULL)\n    return\n  }\n  switch (typeof input) {\n    case `undefined`:\n      hasher.update(UNDEFINED)\n      return\n    case `boolean`:\n      hasher.update(input ? TRUE : FALSE)\n      return\n    case `number`:\n      // Normalize NaNs and -0\n      hasher.update(isNaN(input) ? NaN : input === 0 ? 0 : input)\n      return\n    case `bigint`:\n    case `string`:\n    case `symbol`:\n      hasher.update(input)\n      return\n    case `object`:\n      hasher.update(getCachedHash(input))\n      return\n    case `function`:\n      // Functions are assigned a globally unique ID\n      // and that ID is cached in the weak map\n      hasher.update(cachedReferenceHash(input))\n      return\n    default:\n      console.warn(\n        `Ignored input during hashing because it is of type ${typeof input} which is not supported`\n      )\n  }\n}\n\nfunction getCachedHash(input: object): number {\n  let valueHash = hashCache.get(input)\n  if (valueHash === undefined) {\n    valueHash = hashObject(input)\n  }\n  return valueHash\n}\n\nlet nextRefId = 1\nfunction cachedReferenceHash(fn: object): number {\n  let valueHash = hashCache.get(fn)\n  if (valueHash === undefined) {\n    valueHash = nextRefId ^ FUNCTIONS\n    nextRefId++\n    hashCache.set(fn, valueHash)\n  }\n  return valueHash\n}\n\n/**\n * Strings sorted lexicographically.\n */\nfunction keySort(a: string, b: string): number {\n  return a.localeCompare(b)\n}\n"],"names":["randomHash","MurmurHashStream"],"mappings":"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"}

package/dist/cjs/hashing/hash.d.cts

@@ -0,0 +1 @@
+export declare function hash(input: any): number;

package/dist/cjs/hashing/index.d.cts

@@ -0,0 +1,2 @@
+export { hash } from './hash.js';
+export type { Hash, Hasher } from './murmur.js';

package/dist/cjs/hashing/murmur.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const RANDOM_SEED = randomHash();
+const STRING_MARKER = randomHash();
+const BIG_INT_MARKER = randomHash();
+const NEG_BIG_INT_MARKER = randomHash();
+const SYMBOL_MARKER = randomHash();
+function randomHash() {
+  return Math.random() * (2 ** 31 - 1) >>> 0;
+}
+class MurmurHashStream {
+  constructor() {
+    this.hash = RANDOM_SEED;
+    this.length = 0;
+    this.carry = 0;
+    this.carryBytes = 0;
+  }
+  _mix(k1) {
+    k1 = Math.imul(k1, 3432918353);
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = Math.imul(k1, 461845907);
+    this.hash ^= k1;
+    this.hash = this.hash << 13 | this.hash >>> 19;
+    this.hash = Math.imul(this.hash, 5) + 3864292196;
+  }
+  _writeByte(byte) {
+    this.carry |= (byte & 255) << 8 * this.carryBytes;
+    this.carryBytes++;
+    this.length++;
+    if (this.carryBytes === 4) {
+      this._mix(this.carry >>> 0);
+      this.carry = 0;
+      this.carryBytes = 0;
+    }
+  }
+  update(chunk) {
+    switch (typeof chunk) {
+      case `symbol`: {
+        this.update(SYMBOL_MARKER);
+        const description = chunk.description;
+        if (!description) {
+          return;
+        }
+        for (let i = 0; i < description.length; i++) {
+          const code = description.charCodeAt(i);
+          this._writeByte(code & 255);
+          this._writeByte(code >>> 8 & 255);
+        }
+        return;
+      }
+      case `string`:
+        this.update(STRING_MARKER);
+        for (let i = 0; i < chunk.length; i++) {
+          const code = chunk.charCodeAt(i);
+          this._writeByte(code & 255);
+          this._writeByte(code >>> 8 & 255);
+        }
+        return;
+      case `number`:
+        this._writeByte(chunk & 255);
+        this._writeByte(chunk >>> 8 & 255);
+        this._writeByte(chunk >>> 16 & 255);
+        this._writeByte(chunk >>> 24 & 255);
+        return;
+      case `bigint`: {
+        let value = chunk;
+        if (value < 0n) {
+          value = -value;
+          this.update(NEG_BIG_INT_MARKER);
+        } else {
+          this.update(BIG_INT_MARKER);
+        }
+        while (value > 0n) {
+          this._writeByte(Number(value & 0xffn));
+          value >>= 8n;
+        }
+        if (chunk === 0n) this._writeByte(0);
+        return;
+      }
+      default:
+        throw new TypeError(`Unsupported input type: ${typeof chunk}`);
+    }
+  }
+  digest() {
+    if (this.carryBytes > 0) {
+      let k1 = this.carry >>> 0;
+      k1 = Math.imul(k1, 3432918353);
+      k1 = k1 << 15 | k1 >>> 17;
+      k1 = Math.imul(k1, 461845907);
+      this.hash ^= k1;
+    }
+    this.hash ^= this.length;
+    this.hash ^= this.hash >>> 16;
+    this.hash = Math.imul(this.hash, 2246822507);
+    this.hash ^= this.hash >>> 13;
+    this.hash = Math.imul(this.hash, 3266489909);
+    this.hash ^= this.hash >>> 16;
+    return this.hash >>> 0;
+  }
+}
+exports.MurmurHashStream = MurmurHashStream;
+exports.randomHash = randomHash;
+//# sourceMappingURL=murmur.cjs.map

package/dist/cjs/hashing/murmur.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"murmur.cjs","sources":["../../../src/hashing/murmur.ts"],"sourcesContent":["/*\n * Implementation of murmur hash based on the Composites polyfill implementation:\n * https://github.com/tc39/proposal-composites\n */\n\nconst RANDOM_SEED = randomHash()\nconst STRING_MARKER = randomHash()\nconst BIG_INT_MARKER = randomHash()\nconst NEG_BIG_INT_MARKER = randomHash()\nconst SYMBOL_MARKER = randomHash()\n\nexport type Hash = number\n\nexport function randomHash() {\n  return (Math.random() * (2 ** 31 - 1)) >>> 0\n}\n\nexport interface Hasher {\n  update: (val: symbol | string | number | bigint) => void\n  digest: () => number\n}\n\n/**\n * This implementation of Murmur hash uses a random initial seed and random markers.\n * This means that hashes aren't deterministic across app restarts.\n * This is intentional in the composites polyfill to be resistent to hash-flooding attacks\n * where malicious users would precompute lots of different objects whose hashes collide with each other.\n *\n * Currently, for ts/db-ivm this is fine because we don't persist client state.\n * However, when we will introduce persistence we will either need to store the seeds or remove the randomness\n * to ensure deterministic hashes across app restarts.\n */\nexport class MurmurHashStream implements Hasher {\n  private hash: number = RANDOM_SEED\n  private length = 0\n  private carry = 0\n  private carryBytes = 0\n\n  private _mix(k1: number): void {\n    k1 = Math.imul(k1, 0xcc9e2d51)\n    k1 = (k1 << 15) | (k1 >>> 17)\n    k1 = Math.imul(k1, 0x1b873593)\n    this.hash ^= k1\n    this.hash = (this.hash << 13) | (this.hash >>> 19)\n    this.hash = Math.imul(this.hash, 5) + 0xe6546b64\n  }\n\n  private _writeByte(byte: number): void {\n    this.carry |= (byte & 0xff) << (8 * this.carryBytes)\n    this.carryBytes++\n    this.length++\n\n    if (this.carryBytes === 4) {\n      this._mix(this.carry >>> 0)\n      this.carry = 0\n      this.carryBytes = 0\n    }\n  }\n\n  update(chunk: symbol | string | number | bigint): void {\n    switch (typeof chunk) {\n      case `symbol`: {\n        this.update(SYMBOL_MARKER)\n        const description = chunk.description\n        if (!description) {\n          return\n        }\n\n        for (let i = 0; i < description.length; i++) {\n          const code = description.charCodeAt(i)\n          this._writeByte(code & 0xff)\n          this._writeByte((code >>> 8) & 0xff)\n        }\n        return\n      }\n      case `string`:\n        this.update(STRING_MARKER)\n        for (let i = 0; i < chunk.length; i++) {\n          const code = chunk.charCodeAt(i)\n          this._writeByte(code & 0xff)\n          this._writeByte((code >>> 8) & 0xff)\n        }\n        return\n      case `number`:\n        this._writeByte(chunk & 0xff)\n        this._writeByte((chunk >>> 8) & 0xff)\n        this._writeByte((chunk >>> 16) & 0xff)\n        this._writeByte((chunk >>> 24) & 0xff)\n        return\n      case `bigint`: {\n        let value = chunk\n        if (value < 0n) {\n          value = -value\n          this.update(NEG_BIG_INT_MARKER)\n        } else {\n          this.update(BIG_INT_MARKER)\n        }\n        while (value > 0n) {\n          this._writeByte(Number(value & 0xffn))\n          value >>= 8n\n        }\n        if (chunk === 0n) this._writeByte(0)\n        return\n      }\n      default:\n        throw new TypeError(`Unsupported input type: ${typeof chunk}`)\n    }\n  }\n\n  digest(): number {\n    if (this.carryBytes > 0) {\n      let k1 = this.carry >>> 0\n      k1 = Math.imul(k1, 0xcc9e2d51)\n      k1 = (k1 << 15) | (k1 >>> 17)\n      k1 = Math.imul(k1, 0x1b873593)\n      this.hash ^= k1\n    }\n\n    this.hash ^= this.length\n    this.hash ^= this.hash >>> 16\n    this.hash = Math.imul(this.hash, 0x85ebca6b)\n    this.hash ^= this.hash >>> 13\n    this.hash = Math.imul(this.hash, 0xc2b2ae35)\n    this.hash ^= this.hash >>> 16\n\n    return this.hash >>> 0\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/cjs/hashing/murmur.d.cts

@@ -0,0 +1,26 @@
+export type Hash = number;
+export declare function randomHash(): number;
+export interface Hasher {
+    update: (val: symbol | string | number | bigint) => void;
+    digest: () => number;
+}
+/**
+ * This implementation of Murmur hash uses a random initial seed and random markers.
+ * This means that hashes aren't deterministic across app restarts.
+ * This is intentional in the composites polyfill to be resistent to hash-flooding attacks
+ * where malicious users would precompute lots of different objects whose hashes collide with each other.
+ *
+ * Currently, for ts/db-ivm this is fine because we don't persist client state.
+ * However, when we will introduce persistence we will either need to store the seeds or remove the randomness
+ * to ensure deterministic hashes across app restarts.
+ */
+export declare class MurmurHashStream implements Hasher {
+    private hash;
+    private length;
+    private carry;
+    private carryBytes;
+    private _mix;
+    private _writeByte;
+    update(chunk: symbol | string | number | bigint): void;
+    digest(): number;
+}

package/dist/cjs/indexes.cjs

@@ -6,76 +6,102 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _inner;
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _valueIndex, _hashIndex, _Index_instances, entries_fn, entriesIterators_fn;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const multiset = require("./multiset.cjs");
+const hashIndex = require("./hashIndex.cjs");
+const valueIndex = require("./valueIndex.cjs");
 const utils = require("./utils.cjs");
 class Index {
   constructor() {
-    __privateAdd(this, _inner);
-    __privateSet(this, _inner, new utils.DefaultMap(() => /* @__PURE__ */ new Map()));
+    __privateAdd(this, _Index_instances);
+    /*
+     * This is a hybrid Index that composes a ValueIndex and a HashIndex.
+     * Keys that have only one value are stored in the ValueIndex.
+     * Keys that have multiple values are stored in the HashIndex, the hash distinguishes between the values.
+     * This reduces the amount of hashes we need to compute since often times only a small portion of the keys are updated
+     * so we don't have to hash the keys that are never updated.
+     *
+     * Note: The `valueIndex` and `hashIndex` have disjoint keys.
+     *       When a key that has only one value gets a new distinct value,
+     *       it is added to the `hashIndex` and removed from the `valueIndex` and vice versa.
+     */
+    __privateAdd(this, _valueIndex);
+    __privateAdd(this, _hashIndex);
+    __privateSet(this, _valueIndex, new valueIndex.ValueIndex());
+    __privateSet(this, _hashIndex, new hashIndex.HashIndex());
   }
   toString(indent = false) {
-    return `Index(${JSON.stringify(
-      [...__privateGet(this, _inner)].map(([k, valueMap]) => [k, [...valueMap]]),
-      void 0,
-      indent ? `  ` : void 0
-    )})`;
+    return `Index(
+  ${__privateGet(this, _valueIndex).toString(indent)},
+  ${__privateGet(this, _hashIndex).toString(indent)}
+)`;
   }
   get(key) {
-    const valueMap = __privateGet(this, _inner).get(key);
-    return [...valueMap.entries()];
+    if (__privateGet(this, _valueIndex).has(key)) {
+      return [__privateGet(this, _valueIndex).get(key)];
+    }
+    return __privateGet(this, _hashIndex).get(key);
   }
   getMultiplicity(key, value) {
-    const valueMap = __privateGet(this, _inner).get(key);
-    return valueMap.get(value) ?? 0;
-  }
-  entries() {
-    return __privateGet(this, _inner).entries();
-  }
-  keys() {
-    return __privateGet(this, _inner).keys();
+    if (__privateGet(this, _valueIndex).has(key)) {
+      return __privateGet(this, _valueIndex).getMultiplicity(key);
+    }
+    return __privateGet(this, _hashIndex).getMultiplicity(key, value);
   }
   has(key) {
-    return __privateGet(this, _inner).has(key);
+    return __privateGet(this, _valueIndex).has(key) || __privateGet(this, _hashIndex).has(key);
   }
   get size() {
-    return __privateGet(this, _inner).size;
+    return __privateGet(this, _valueIndex).size + __privateGet(this, _hashIndex).size;
   }
   addValue(key, value) {
-    const [val, multiplicity] = value;
-    const valueMap = __privateGet(this, _inner).get(key);
-    const existingMultiplicity = valueMap.get(val) ?? 0;
-    const newMultiplicity = existingMultiplicity + multiplicity;
-    if (multiplicity !== 0) {
-      if (newMultiplicity === 0) {
-        valueMap.delete(val);
-      } else {
-        valueMap.set(val, newMultiplicity);
+    const containedInValueIndex = __privateGet(this, _valueIndex).has(key);
+    const containedInHashIndex = __privateGet(this, _hashIndex).has(key);
+    if (containedInHashIndex && containedInValueIndex) {
+      throw new Error(
+        `Key ${key} is contained in both the value index and the hash index. This should never happen because they should have disjoint keysets.`
+      );
+    }
+    if (!containedInValueIndex && !containedInHashIndex) {
+      __privateGet(this, _valueIndex).addValue(key, value);
+      return;
+    }
+    if (containedInValueIndex) {
+      try {
+        __privateGet(this, _valueIndex).addValue(key, value);
+      } catch {
+        const existingValue = __privateGet(this, _valueIndex).get(key);
+        __privateGet(this, _valueIndex).delete(key);
+        __privateGet(this, _hashIndex).addValue(key, existingValue);
+        __privateGet(this, _hashIndex).addValue(key, value);
+      }
+      return;
+    }
+    if (containedInHashIndex) {
+      const singleRemainingValue = __privateGet(this, _hashIndex).addValue(key, value);
+      if (singleRemainingValue) {
+        __privateGet(this, _hashIndex).delete(key);
+        __privateGet(this, _valueIndex).addValue(key, singleRemainingValue);
       }
+      return;
     }
   }
   append(other) {
-    for (const [key, otherValueMap] of other.entries()) {
-      const thisValueMap = __privateGet(this, _inner).get(key);
-      for (const [value, multiplicity] of otherValueMap.entries()) {
-        const existingMultiplicity = thisValueMap.get(value) ?? 0;
-        const newMultiplicity = existingMultiplicity + multiplicity;
-        if (newMultiplicity === 0) {
-          thisValueMap.delete(value);
-        } else {
-          thisValueMap.set(value, newMultiplicity);
-        }
-      }
+    var _a;
+    for (const [key, value] of __privateMethod(_a = other, _Index_instances, entries_fn).call(_a)) {
+      this.addValue(key, value);
     }
   }
   join(other) {
+    var _a;
     const result = [];
     if (this.size <= other.size) {
-      for (const [key, valueMap] of this.entries()) {
+      for (const [key, valueIt] of __privateMethod(this, _Index_instances, entriesIterators_fn).call(this)) {
         if (!other.has(key)) continue;
         const otherValues = other.get(key);
-        for (const [val1, mul1] of valueMap.entries()) {
+        for (const [val1, mul1] of valueIt) {
           for (const [val2, mul2] of otherValues) {
             if (mul1 !== 0 && mul2 !== 0) {
               result.push([[key, [val1, val2]], mul1 * mul2]);
@@ -84,10 +110,10 @@ class Index {
         }
       }
     } else {
-      for (const [key, otherValueMap] of other.entries()) {
+      for (const [key, otherValueIt] of __privateMethod(_a = other, _Index_instances, entriesIterators_fn).call(_a)) {
         if (!this.has(key)) continue;
         const values = this.get(key);
-        for (const [val2, mul2] of otherValueMap.entries()) {
+        for (const [val2, mul2] of otherValueIt) {
           for (const [val1, mul1] of values) {
             if (mul1 !== 0 && mul2 !== 0) {
               result.push([[key, [val1, val2]], mul1 * mul2]);
@@ -99,6 +125,32 @@ class Index {
     return new multiset.MultiSet(result);
   }
 }
-_inner = new WeakMap();
+_valueIndex = new WeakMap();
+_hashIndex = new WeakMap();
+_Index_instances = new WeakSet();
+/**
+ * This returns an iterator that iterates over all key-value pairs.
+ * @returns An iterable of all key-value pairs (and their multiplicities) in the index.
+ */
+entries_fn = function() {
+  return utils.concatIterable(
+    __privateGet(this, _valueIndex).entries(),
+    __privateGet(this, _hashIndex).entriesIterator()
+  );
+};
+entriesIterators_fn = function* () {
+  for (const [key, [value, multiplicity]] of __privateGet(this, _valueIndex).entries()) {
+    yield [key, /* @__PURE__ */ new Map([[value, multiplicity]])];
+  }
+  for (const [key, valueMap] of __privateGet(this, _hashIndex).entries()) {
+    yield [
+      key,
+      utils.mapIterable(valueMap, ([_hash, [value, multiplicity]]) => [
+        value,
+        multiplicity
+      ])
+    ];
+  }
+};
 exports.Index = Index;
 //# sourceMappingURL=indexes.cjs.map

package/dist/cjs/indexes.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"indexes.cjs","sources":["../../src/indexes.ts"],"sourcesContent":["import { MultiSet } from \"./multiset.js\"\nimport { DefaultMap } from \"./utils.js\"\n\n/**\n * A map from a difference collection trace's keys -> (value, multiplicities) that changed.\n * Used in operations like join and reduce where the operation needs to\n * exploit the key-value structure of the data to run efficiently.\n */\nexport class Index<K, V> {\n  #inner: DefaultMap<K, Map<V, number>>\n\n  constructor() {\n    this.#inner = new DefaultMap<K, Map<V, number>>(() => new Map<V, number>())\n    // #inner is a map of:\n    // {\n    //   [key]: Map<V, number>  // Direct value-to-multiplicity mapping\n    // }\n  }\n\n  toString(indent = false): string {\n    return `Index(${JSON.stringify(\n      [...this.#inner].map(([k, valueMap]) => [k, [...valueMap]]),\n      undefined,\n      indent ? `  ` : undefined\n    )})`\n  }\n\n  get(key: K): Array<[V, number]> {\n    const valueMap = this.#inner.get(key)\n    return [...valueMap.entries()]\n  }\n\n  getMultiplicity(key: K, value: V): number {\n    const valueMap = this.#inner.get(key)\n    return valueMap.get(value) ?? 0\n  }\n\n  entries() {\n    return this.#inner.entries()\n  }\n\n  keys() {\n    return this.#inner.keys()\n  }\n\n  has(key: K): boolean {\n    return this.#inner.has(key)\n  }\n\n  get size(): number {\n    return this.#inner.size\n  }\n\n  addValue(key: K, value: [V, number]): void {\n    const [val, multiplicity] = value\n    const valueMap = this.#inner.get(key)\n    const existingMultiplicity = valueMap.get(val) ?? 0\n    const newMultiplicity = existingMultiplicity + multiplicity\n\n    if (multiplicity !== 0) {\n      if (newMultiplicity === 0) {\n        valueMap.delete(val)\n      } else {\n        valueMap.set(val, newMultiplicity)\n      }\n    }\n  }\n\n  append(other: Index<K, V>): void {\n    for (const [key, otherValueMap] of other.entries()) {\n      const thisValueMap = this.#inner.get(key)\n      for (const [value, multiplicity] of otherValueMap.entries()) {\n        const existingMultiplicity = thisValueMap.get(value) ?? 0\n        const newMultiplicity = existingMultiplicity + multiplicity\n        if (newMultiplicity === 0) {\n          thisValueMap.delete(value)\n        } else {\n          thisValueMap.set(value, newMultiplicity)\n        }\n      }\n    }\n  }\n\n  join<V2>(other: Index<K, V2>): MultiSet<[K, [V, V2]]> {\n    const result: Array<[[K, [V, V2]], number]> = []\n\n    // We want to iterate over the smaller of the two indexes to reduce the\n    // number of operations we need to do.\n    if (this.size <= other.size) {\n      for (const [key, valueMap] of this.entries()) {\n        if (!other.has(key)) continue\n        const otherValues = other.get(key)\n        for (const [val1, mul1] of valueMap.entries()) {\n          for (const [val2, mul2] of otherValues) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    } else {\n      for (const [key, otherValueMap] of other.entries()) {\n        if (!this.has(key)) continue\n        const values = this.get(key)\n        for (const [val2, mul2] of otherValueMap.entries()) {\n          for (const [val1, mul1] of values) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    }\n\n    return new MultiSet(result)\n  }\n}\n"],"names":["DefaultMap","MultiSet"],"mappings":"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"}
+{"version":3,"file":"indexes.cjs","sources":["../../src/indexes.ts"],"sourcesContent":["import { MultiSet } from \"./multiset.js\"\nimport { HashIndex } from \"./hashIndex.js\"\nimport { ValueIndex } from \"./valueIndex.js\"\nimport { concatIterable, mapIterable } from \"./utils.js\"\n\n/**\n * A map from a difference collection trace's keys -> (value, multiplicities) that changed.\n * Used in operations like join and reduce where the operation needs to\n * exploit the key-value structure of the data to run efficiently.\n */\nexport class Index<K, V> {\n  /*\n   * This is a hybrid Index that composes a ValueIndex and a HashIndex.\n   * Keys that have only one value are stored in the ValueIndex.\n   * Keys that have multiple values are stored in the HashIndex, the hash distinguishes between the values.\n   * This reduces the amount of hashes we need to compute since often times only a small portion of the keys are updated\n   * so we don't have to hash the keys that are never updated.\n   *\n   * Note: The `valueIndex` and `hashIndex` have disjoint keys.\n   *       When a key that has only one value gets a new distinct value,\n   *       it is added to the `hashIndex` and removed from the `valueIndex` and vice versa.\n   */\n  #valueIndex: ValueIndex<K, V>\n  #hashIndex: HashIndex<K, V>\n\n  constructor() {\n    this.#valueIndex = new ValueIndex<K, V>()\n    this.#hashIndex = new HashIndex<K, V>()\n  }\n\n  toString(indent = false): string {\n    return `Index(\\n  ${this.#valueIndex.toString(indent)},\\n  ${this.#hashIndex.toString(indent)}\\n)`\n  }\n\n  get(key: K): Array<[V, number]> {\n    if (this.#valueIndex.has(key)) {\n      return [this.#valueIndex.get(key)!]\n    }\n    return this.#hashIndex.get(key)\n  }\n\n  getMultiplicity(key: K, value: V): number {\n    if (this.#valueIndex.has(key)) {\n      return this.#valueIndex.getMultiplicity(key)\n    }\n    return this.#hashIndex.getMultiplicity(key, value)\n  }\n\n  /**\n   * This returns an iterator that iterates over all key-value pairs.\n   * @returns An iterable of all key-value pairs (and their multiplicities) in the index.\n   */\n  #entries(): Iterable<[K, [V, number]]> {\n    return concatIterable(\n      this.#valueIndex.entries(),\n      this.#hashIndex.entriesIterator()\n    )\n  }\n\n  /**\n   * This method only iterates over the keys and not over the values.\n   * Hence, it is more efficient than the `#entries` method.\n   * It returns an iterator that you can use if you need to iterate over the values for a given key.\n   * @returns An iterator of all *keys* in the index and their corresponding value iterator.\n   */\n  *#entriesIterators(): Iterable<[K, Iterable<[V, number]>]> {\n    for (const [key, [value, multiplicity]] of this.#valueIndex.entries()) {\n      yield [key, new Map<V, number>([[value, multiplicity]])]\n    }\n    for (const [key, valueMap] of this.#hashIndex.entries()) {\n      yield [\n        key,\n        mapIterable(valueMap, ([_hash, [value, multiplicity]]) => [\n          value,\n          multiplicity,\n        ]),\n      ]\n    }\n  }\n\n  has(key: K): boolean {\n    return this.#valueIndex.has(key) || this.#hashIndex.has(key)\n  }\n\n  get size(): number {\n    return this.#valueIndex.size + this.#hashIndex.size\n  }\n\n  addValue(key: K, value: [V, number]): void {\n    const containedInValueIndex = this.#valueIndex.has(key)\n    const containedInHashIndex = this.#hashIndex.has(key)\n\n    if (containedInHashIndex && containedInValueIndex) {\n      throw new Error(\n        `Key ${key} is contained in both the value index and the hash index. This should never happen because they should have disjoint keysets.`\n      )\n    }\n\n    if (!containedInValueIndex && !containedInHashIndex) {\n      // This is the first time we see the key\n      // Add it to the value index\n      this.#valueIndex.addValue(key, value)\n      return\n    }\n\n    if (containedInValueIndex) {\n      // This key is already in the value index\n      // It could be that it's the same value or a different one\n      // If it's a different value we will need to remove the key from the value index\n      // and add the key and its two values to the hash index\n      try {\n        this.#valueIndex.addValue(key, value)\n      } catch {\n        // This is a different value, need to move the key to the hash index\n        const existingValue = this.#valueIndex.get(key)!\n        this.#valueIndex.delete(key)\n        this.#hashIndex.addValue(key, existingValue)\n        this.#hashIndex.addValue(key, value)\n      }\n      return\n    }\n\n    if (containedInHashIndex) {\n      // This key is already in the hash index so it already has two or more values.\n      // However, this new value and multiplicity could cause an existing value to be removed\n      // and lead to the key having only a single value in which case we need to move it back to the value index\n      const singleRemainingValue = this.#hashIndex.addValue(key, value)\n      if (singleRemainingValue) {\n        // The key only has a single remaining value so we need to move it back to the value index\n        this.#hashIndex.delete(key)\n        this.#valueIndex.addValue(key, singleRemainingValue)\n      }\n      return\n    }\n  }\n\n  append(other: Index<K, V>): void {\n    for (const [key, value] of other.#entries()) {\n      this.addValue(key, value)\n    }\n  }\n\n  join<V2>(other: Index<K, V2>): MultiSet<[K, [V, V2]]> {\n    const result: Array<[[K, [V, V2]], number]> = []\n\n    // We want to iterate over the smaller of the two indexes to reduce the\n    // number of operations we need to do.\n    if (this.size <= other.size) {\n      for (const [key, valueIt] of this.#entriesIterators()) {\n        if (!other.has(key)) continue\n        const otherValues = other.get(key)\n        for (const [val1, mul1] of valueIt) {\n          for (const [val2, mul2] of otherValues) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    } else {\n      for (const [key, otherValueIt] of other.#entriesIterators()) {\n        if (!this.has(key)) continue\n        const values = this.get(key)\n        for (const [val2, mul2] of otherValueIt) {\n          for (const [val1, mul1] of values) {\n            if (mul1 !== 0 && mul2 !== 0) {\n              result.push([[key, [val1, val2]], mul1 * mul2])\n            }\n          }\n        }\n      }\n    }\n\n    return new MultiSet(result)\n  }\n}\n"],"names":["ValueIndex","HashIndex","MultiSet","concatIterable","mapIterable"],"mappings":"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"}