@tanstack/db-ivm 0.1.3 → 0.1.5

package/dist/cjs/hashing/hash.cjs

@@ -40,7 +40,7 @@ function hashObject(input) {
       marker = SET_MARKER;
       plainObjectInput = [...input.entries()];
     }
-    if (input instanceof Buffer || input instanceof Uint8Array || input instanceof File) {
+    if (typeof Buffer !== `undefined` && input instanceof Buffer || input instanceof Uint8Array || input instanceof File) {
       return cachedReferenceHash(input);
     }
     valueHash = hashPlainObject(plainObjectInput, marker);

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

@@ -1 +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":";;;AAQA,MAAM,OAAOA,OAAAA,WAAA;AACb,MAAM,QAAQA,OAAAA,WAAA;AACd,MAAM,OAAOA,OAAAA,WAAA;AACb,MAAM,YAAYA,OAAAA,WAAA;AAClB,MAAM,MAAMA,OAAAA,WAAA;AACZ,MAAM,YAAYA,OAAAA,WAAA;AAClB,MAAM,cAAcA,OAAAA,WAAA;AACpB,MAAM,gBAAgBA,OAAAA,WAAA;AACtB,MAAM,eAAeA,OAAAA,WAAA;AACrB,MAAM,aAAaA,OAAAA,WAAA;AACnB,MAAM,aAAaA,OAAAA,WAAA;AAEnB,MAAM,gCAAgB,QAAA;AAEf,SAAS,KAAK,OAAoB;AACvC,QAAM,SAAS,IAAIC,wBAAA;AACnB,eAAa,QAAQ,KAAK;AAC1B,SAAO,OAAO,OAAA;AAChB;AAEA,SAAS,WAAW,OAAuB;AACzC,QAAM,aAAa,UAAU,IAAI,KAAK;AACtC,MAAI,eAAe,QAAW;AAC5B,WAAO;AAAA,EACT;AAEA,MAAI;AACJ,MAAI,iBAAiB,MAAM;AACzB,gBAAY,SAAS,KAAK;AAAA,EAC5B,OAAO;AACL,QAAI,mBAAmB;AACvB,QAAI,SAAS;AAEb,QAAI,iBAAiB,OAAO;AAC1B,eAAS;AAAA,IACX;AAEA,QAAI,iBAAiB,KAAK;AACxB,eAAS;AACT,yBAAmB,CAAC,GAAG,MAAM,SAAS;AAAA,IACxC;AAEA,QAAI,iBAAiB,KAAK;AACxB,eAAS;AACT,yBAAmB,CAAC,GAAG,MAAM,SAAS;AAAA,IACxC;AAEA,QACE,iBAAiB,UACjB,iBAAiB,cACjB,iBAAiB,MACjB;AAIA,aAAO,oBAAoB,KAAK;AAAA,IAClC;AAEA,gBAAY,gBAAgB,kBAAkB,MAAM;AAAA,EACtD;AAEA,YAAU,IAAI,OAAO,SAAS;AAC9B,SAAO;AACT;AAEA,SAAS,SAAS,OAAqB;AACrC,QAAM,SAAS,IAAIA,wBAAA;AACnB,SAAO,OAAO,WAAW;AACzB,SAAO,OAAO,MAAM,SAAS;AAC7B,SAAO,OAAO,OAAA;AAChB;AAEA,SAAS,gBAAgB,OAAe,QAAwB;AAC9D,QAAM,SAAS,IAAIA,wBAAA;AAGnB,SAAO,OAAO,MAAM;AACpB,QAAM,OAAO,OAAO,KAAK,KAAK;AAC9B,OAAK,KAAK,OAAO;AACjB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AACjB,WAAO,OAAO,GAAG;AACjB,iBAAa,QAAQ,MAAM,GAAyB,CAAC;AAAA,EACvD;AAEA,SAAO,OAAO,OAAA;AAChB;AAEA,SAAS,aAAa,QAAgB,OAAsB;AAC1D,MAAI,UAAU,MAAM;AAClB,WAAO,OAAO,IAAI;AAClB;AAAA,EACF;AACA,UAAQ,OAAO,OAAA;AAAA,IACb,KAAK;AACH,aAAO,OAAO,SAAS;AACvB;AAAA,IACF,KAAK;AACH,aAAO,OAAO,QAAQ,OAAO,KAAK;AAClC;AAAA,IACF,KAAK;AAEH,aAAO,OAAO,MAAM,KAAK,IAAI,MAAM,UAAU,IAAI,IAAI,KAAK;AAC1D;AAAA,IACF,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO,OAAO,KAAK;AACnB;AAAA,IACF,KAAK;AACH,aAAO,OAAO,cAAc,KAAK,CAAC;AAClC;AAAA,IACF,KAAK;AAGH,aAAO,OAAO,oBAAoB,KAAK,CAAC;AACxC;AAAA,IACF;AACE,cAAQ;AAAA,QACN,sDAAsD,OAAO,KAAK;AAAA,MAAA;AAAA,EACpE;AAEN;AAEA,SAAS,cAAc,OAAuB;AAC5C,MAAI,YAAY,UAAU,IAAI,KAAK;AACnC,MAAI,cAAc,QAAW;AAC3B,gBAAY,WAAW,KAAK;AAAA,EAC9B;AACA,SAAO;AACT;AAEA,IAAI,YAAY;AAChB,SAAS,oBAAoB,IAAoB;AAC/C,MAAI,YAAY,UAAU,IAAI,EAAE;AAChC,MAAI,cAAc,QAAW;AAC3B,gBAAY,YAAY;AACxB;AACA,cAAU,IAAI,IAAI,SAAS;AAAA,EAC7B;AACA,SAAO;AACT;AAKA,SAAS,QAAQ,GAAW,GAAmB;AAC7C,SAAO,EAAE,cAAc,CAAC;AAC1B;;"}
+{"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      (typeof Buffer !== `undefined` && 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/murmur.cjs

@@ -8,6 +8,9 @@ const SYMBOL_MARKER = randomHash();
 function randomHash() {
   return Math.random() * (2 ** 31 - 1) >>> 0;
 }
+const buf = new ArrayBuffer(8);
+const dv = new DataView(buf);
+const u8 = new Uint8Array(buf);
 class MurmurHashStream {
   constructor() {
     this.hash = RANDOM_SEED;
@@ -57,10 +60,15 @@ class MurmurHashStream {
         }
         return;
       case `number`:
-        this._writeByte(chunk & 255);
-        this._writeByte(chunk >>> 8 & 255);
-        this._writeByte(chunk >>> 16 & 255);
-        this._writeByte(chunk >>> 24 & 255);
+        dv.setFloat64(0, chunk, true);
+        this._writeByte(u8[0]);
+        this._writeByte(u8[1]);
+        this._writeByte(u8[2]);
+        this._writeByte(u8[3]);
+        this._writeByte(u8[4]);
+        this._writeByte(u8[5]);
+        this._writeByte(u8[6]);
+        this._writeByte(u8[7]);
         return;
       case `bigint`: {
         let value = chunk;

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

@@ -1 +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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"}
+{"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// Allocate these once, outside the hot path\nconst buf = new ArrayBuffer(8)\n// dv and u8 are 2 different views on the same buffer `buf`\nconst dv = new DataView(buf)\nconst u8 = new Uint8Array(buf)\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        dv.setFloat64(0, chunk, true) // fixed little-endian\n        this._writeByte(u8[0]!)\n        this._writeByte(u8[1]!)\n        this._writeByte(u8[2]!)\n        this._writeByte(u8[3]!)\n        this._writeByte(u8[4]!)\n        this._writeByte(u8[5]!)\n        this._writeByte(u8[6]!)\n        this._writeByte(u8[7]!)\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/esm/hashing/hash.js

@@ -38,7 +38,7 @@ function hashObject(input) {
       marker = SET_MARKER;
       plainObjectInput = [...input.entries()];
     }
-    if (input instanceof Buffer || input instanceof Uint8Array || input instanceof File) {
+    if (typeof Buffer !== `undefined` && input instanceof Buffer || input instanceof Uint8Array || input instanceof File) {
       return cachedReferenceHash(input);
     }
     valueHash = hashPlainObject(plainObjectInput, marker);

package/dist/esm/hashing/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","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":[],"mappings":"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"}
+{"version":3,"file":"hash.js","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      (typeof Buffer !== `undefined` && 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":[],"mappings":"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"}

package/dist/esm/hashing/murmur.js

@@ -6,6 +6,9 @@ const SYMBOL_MARKER = randomHash();
 function randomHash() {
   return Math.random() * (2 ** 31 - 1) >>> 0;
 }
+const buf = new ArrayBuffer(8);
+const dv = new DataView(buf);
+const u8 = new Uint8Array(buf);
 class MurmurHashStream {
   constructor() {
     this.hash = RANDOM_SEED;
@@ -55,10 +58,15 @@ class MurmurHashStream {
         }
         return;
       case `number`:
-        this._writeByte(chunk & 255);
-        this._writeByte(chunk >>> 8 & 255);
-        this._writeByte(chunk >>> 16 & 255);
-        this._writeByte(chunk >>> 24 & 255);
+        dv.setFloat64(0, chunk, true);
+        this._writeByte(u8[0]);
+        this._writeByte(u8[1]);
+        this._writeByte(u8[2]);
+        this._writeByte(u8[3]);
+        this._writeByte(u8[4]);
+        this._writeByte(u8[5]);
+        this._writeByte(u8[6]);
+        this._writeByte(u8[7]);
         return;
       case `bigint`: {
         let value = chunk;

package/dist/esm/hashing/murmur.js.map

@@ -1 +1 @@
-{"version":3,"file":"murmur.js","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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"}
+{"version":3,"file":"murmur.js","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// Allocate these once, outside the hot path\nconst buf = new ArrayBuffer(8)\n// dv and u8 are 2 different views on the same buffer `buf`\nconst dv = new DataView(buf)\nconst u8 = new Uint8Array(buf)\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        dv.setFloat64(0, chunk, true) // fixed little-endian\n        this._writeByte(u8[0]!)\n        this._writeByte(u8[1]!)\n        this._writeByte(u8[2]!)\n        this._writeByte(u8[3]!)\n        this._writeByte(u8[4]!)\n        this._writeByte(u8[5]!)\n        this._writeByte(u8[6]!)\n        this._writeByte(u8[7]!)\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/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@tanstack/db-ivm",
   "description": "Incremental View Maintenance for TanStack DB based on Differential Dataflow",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "dependencies": {
     "fractional-indexing": "^3.2.0",
     "sorted-btree": "^1.8.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "@vitest/coverage-istanbul": "^3.0.9"
+    "@vitest/coverage-istanbul": "^3.2.4"
   },
   "exports": {
     ".": {

package/src/hashing/hash.ts

@@ -54,7 +54,7 @@ function hashObject(input: object): number {
     }
 
     if (
-      input instanceof Buffer ||
+      (typeof Buffer !== `undefined` && input instanceof Buffer) ||
       input instanceof Uint8Array ||
       input instanceof File
     ) {

package/src/hashing/murmur.ts

@@ -20,6 +20,12 @@ export interface Hasher {
   digest: () => number
 }
 
+// Allocate these once, outside the hot path
+const buf = new ArrayBuffer(8)
+// dv and u8 are 2 different views on the same buffer `buf`
+const dv = new DataView(buf)
+const u8 = new Uint8Array(buf)
+
 /**
  * This implementation of Murmur hash uses a random initial seed and random markers.
  * This means that hashes aren't deterministic across app restarts.
@@ -82,10 +88,15 @@ export class MurmurHashStream implements Hasher {
         }
         return
       case `number`:
-        this._writeByte(chunk & 0xff)
-        this._writeByte((chunk >>> 8) & 0xff)
-        this._writeByte((chunk >>> 16) & 0xff)
-        this._writeByte((chunk >>> 24) & 0xff)
+        dv.setFloat64(0, chunk, true) // fixed little-endian
+        this._writeByte(u8[0]!)
+        this._writeByte(u8[1]!)
+        this._writeByte(u8[2]!)
+        this._writeByte(u8[3]!)
+        this._writeByte(u8[4]!)
+        this._writeByte(u8[5]!)
+        this._writeByte(u8[6]!)
+        this._writeByte(u8[7]!)
         return
       case `bigint`: {
         let value = chunk