eigen-db 4.0.2 → 4.1.0

package/dist/eigen-db.js

@@ -1,113 +1,113 @@
-class b extends Error {
-  constructor(e) {
-    super(`Capacity exceeded. Max vectors for this dimension size is ~${e}.`), this.name = "VectorCapacityExceededError";
+class Q extends Error {
+  constructor(A) {
+    super(`Capacity exceeded. Max vectors for this dimension size is ~${A}.`), this.name = "VectorCapacityExceededError";
   }
 }
-class E {
+class C {
   dirHandle = null;
   dirName;
-  constructor(e) {
-    this.dirName = e;
+  constructor(A) {
+    this.dirName = A;
   }
   async getDir() {
     if (!this.dirHandle) {
-      const e = await navigator.storage.getDirectory();
-      this.dirHandle = await e.getDirectoryHandle(this.dirName, { create: !0 });
+      const A = await navigator.storage.getDirectory();
+      this.dirHandle = await A.getDirectoryHandle(this.dirName, { create: !0 });
     }
     return this.dirHandle;
   }
-  async readAll(e) {
+  async readAll(A) {
     try {
-      const n = await (await (await (await this.getDir()).getFileHandle(e)).getFile()).arrayBuffer();
-      return new Uint8Array(n);
+      const r = await (await (await (await this.getDir()).getFileHandle(A)).getFile()).arrayBuffer();
+      return new Uint8Array(r);
     } catch {
       return new Uint8Array(0);
     }
   }
-  async append(e, t) {
-    const r = await (await this.getDir()).getFileHandle(e, { create: !0 }), n = await r.createWritable({ keepExistingData: !0 }), i = await r.getFile();
-    await n.seek(i.size), await n.write(t), await n.close();
+  async append(A, e) {
+    const t = await (await this.getDir()).getFileHandle(A, { create: !0 }), r = await t.createWritable({ keepExistingData: !0 }), o = await t.getFile();
+    await r.seek(o.size), await r.write(e), await r.close();
   }
-  async write(e, t) {
-    const n = await (await (await this.getDir()).getFileHandle(e, { create: !0 })).createWritable({ keepExistingData: !1 });
-    await n.write(t), await n.close();
+  async write(A, e) {
+    const r = await (await (await this.getDir()).getFileHandle(A, { create: !0 })).createWritable({ keepExistingData: !1 });
+    await r.write(e), await r.close();
   }
   async destroy() {
     await (await navigator.storage.getDirectory()).removeEntry(this.dirName, { recursive: !0 }), this.dirHandle = null;
   }
 }
-class D {
+class O {
   files = /* @__PURE__ */ new Map();
-  async readAll(e) {
-    const t = this.files.get(e);
-    if (!t || t.length === 0) return new Uint8Array(0);
-    const s = t.reduce((i, o) => i + o.byteLength, 0), r = new Uint8Array(s);
-    let n = 0;
-    for (const i of t)
-      r.set(i, n), n += i.byteLength;
-    return r;
+  async readAll(A) {
+    const e = this.files.get(A);
+    if (!e || e.length === 0) return new Uint8Array(0);
+    const s = e.reduce((o, a) => o + a.byteLength, 0), t = new Uint8Array(s);
+    let r = 0;
+    for (const o of e)
+      t.set(o, r), r += o.byteLength;
+    return t;
   }
-  async append(e, t) {
-    this.files.has(e) || this.files.set(e, []), this.files.get(e).push(new Uint8Array(t));
+  async append(A, e) {
+    this.files.has(A) || this.files.set(A, []), this.files.get(A).push(new Uint8Array(e));
   }
-  async write(e, t) {
-    this.files.set(e, [new Uint8Array(t)]);
+  async write(A, e) {
+    this.files.set(A, [new Uint8Array(e)]);
   }
   async destroy() {
     this.files.clear();
   }
 }
-function B(a) {
-  let e = 0;
-  for (let r = 0; r < a.length; r++)
-    e += a[r] * a[r];
-  const t = Math.sqrt(e);
-  if (t === 0) return;
-  const s = 1 / t;
-  for (let r = 0; r < a.length; r++)
-    a[r] *= s;
+function E(n) {
+  let A = 0;
+  for (let t = 0; t < n.length; t++)
+    A += n[t] * n[t];
+  const e = Math.sqrt(A);
+  if (e === 0) return;
+  const s = 1 / e;
+  for (let t = 0; t < n.length; t++)
+    n[t] *= s;
 }
-function M(a, e, t, s, r) {
-  for (let n = 0; n < s; n++) {
-    let i = 0;
-    const o = n * r;
-    for (let A = 0; A < r; A++)
-      i += a[A] * e[o + A];
-    t[n] = i;
+function b(n, A, e, s, t) {
+  for (let r = 0; r < s; r++) {
+    let o = 0;
+    const a = r * t;
+    for (let i = 0; i < t; i++)
+      o += n[i] * A[a + i];
+    e[r] = o;
   }
 }
-const I = new TextEncoder(), Q = new TextDecoder();
-function S(a) {
-  const e = a.map((o) => I.encode(o)), t = e.reduce((o, A) => o + 4 + A.byteLength, 0), s = new ArrayBuffer(t), r = new DataView(s), n = new Uint8Array(s);
-  let i = 0;
-  for (const o of e)
-    r.setUint32(i, o.byteLength, !0), i += 4, n.set(o, i), i += o.byteLength;
-  return n;
+const M = new TextEncoder(), D = new TextDecoder();
+function S(n) {
+  const A = n.map((a) => M.encode(a)), e = A.reduce((a, i) => a + 4 + i.byteLength, 0), s = new ArrayBuffer(e), t = new DataView(s), r = new Uint8Array(s);
+  let o = 0;
+  for (const a of A)
+    t.setUint32(o, a.byteLength, !0), o += 4, r.set(a, o), o += a.byteLength;
+  return r;
 }
-function O(a) {
-  const e = [], t = new DataView(a.buffer, a.byteOffset, a.byteLength);
+function k(n) {
+  const A = [], e = new DataView(n.buffer, n.byteOffset, n.byteLength);
   let s = 0;
-  for (; s < a.byteLength; ) {
-    const r = t.getUint32(s, !0);
+  for (; s < n.byteLength; ) {
+    const t = e.getUint32(s, !0);
     s += 4;
-    const n = Q.decode(a.subarray(s, s + r));
-    e.push(n), s += r;
+    const r = D.decode(n.subarray(s, s + t));
+    A.push(r), s += t;
   }
-  return e;
+  return A;
 }
-const y = 65536, d = 65536;
-class p {
+const f = 65536, d = 65536;
+class v {
   memory;
   dimensions;
   queryOffset;
   dbOffset;
   _vectorCount;
-  constructor(e, t = 0) {
-    this.dimensions = e, this.queryOffset = 0;
-    const s = e * 4;
-    this.dbOffset = Math.ceil(s / y) * y;
-    const r = t * e * 4, n = this.dbOffset + r, i = Math.max(1, Math.ceil(n / y));
-    this.memory = new WebAssembly.Memory({ initial: i }), this._vectorCount = t;
+  constructor(A, e = 0) {
+    this.dimensions = A, this.queryOffset = 0;
+    const s = A * 4;
+    this.dbOffset = Math.ceil(s / f) * f;
+    const t = e * A * 4, r = this.dbOffset + t, o = Math.max(1, Math.ceil(r / f));
+    this.memory = new WebAssembly.Memory({ initial: o }), this._vectorCount = e;
   }
   /** Current number of vectors stored */
   get vectorCount() {
@@ -126,45 +126,45 @@ class p {
    * Accounts for query buffer, DB space, and scores buffer.
    */
   get maxVectors() {
-    const e = d * y - this.dbOffset, t = this.dimensions * 4 + 4;
-    return Math.floor(e / t);
+    const A = d * f - this.dbOffset, e = this.dimensions * 4 + 4;
+    return Math.floor(A / e);
   }
   /**
    * Ensures memory is large enough for the current DB + scores buffer.
    * Calls memory.grow() if needed.
    */
-  ensureCapacity(e) {
-    const t = this._vectorCount + e, s = this.dbOffset + t * this.dimensions * 4 + t * 4, r = this.memory.buffer.byteLength;
-    if (s > r) {
-      const n = Math.ceil((s - r) / y);
-      if (r / y + n > d)
+  ensureCapacity(A) {
+    const e = this._vectorCount + A, s = this.dbOffset + e * this.dimensions * 4 + e * 4, t = this.memory.buffer.byteLength;
+    if (s > t) {
+      const r = Math.ceil((s - t) / f);
+      if (t / f + r > d)
         throw new Error("WASM memory limit exceeded");
-      this.memory.grow(n);
+      this.memory.grow(r);
     }
   }
   /**
    * Write a query vector into the query buffer region.
    */
-  writeQuery(e) {
-    new Float32Array(this.memory.buffer, this.queryOffset, this.dimensions).set(e);
+  writeQuery(A) {
+    new Float32Array(this.memory.buffer, this.queryOffset, this.dimensions).set(A);
   }
   /**
    * Append vectors to the database region.
    * Returns the byte offset where the new vectors were written.
    */
-  appendVectors(e) {
-    const t = this.dbOffset + this._vectorCount * this.dimensions * 4;
-    let s = t;
-    for (const r of e)
-      new Float32Array(this.memory.buffer, s, this.dimensions).set(r), s += this.dimensions * 4;
-    return this._vectorCount += e.length, t;
+  appendVectors(A) {
+    const e = this.dbOffset + this._vectorCount * this.dimensions * 4;
+    let s = e;
+    for (const t of A)
+      new Float32Array(this.memory.buffer, s, this.dimensions).set(t), s += this.dimensions * 4;
+    return this._vectorCount += A.length, e;
   }
   /**
    * Load raw vector bytes directly into the database region.
    * Used for bulk loading from OPFS.
    */
-  loadVectorBytes(e, t) {
-    new Uint8Array(this.memory.buffer, this.dbOffset, e.byteLength).set(e), this._vectorCount = t;
+  loadVectorBytes(A, e) {
+    new Uint8Array(this.memory.buffer, this.dbOffset, A.byteLength).set(A), this._vectorCount = e;
   }
   /**
    * Read the scores buffer as a Float32Array view.
@@ -175,16 +175,16 @@ class p {
   /**
    * Read the DB region for a specific vector index.
    */
-  readVector(e) {
-    const t = this.dbOffset + e * this.dimensions * 4;
-    return new Float32Array(this.memory.buffer, t, this.dimensions);
+  readVector(A) {
+    const e = this.dbOffset + A * this.dimensions * 4;
+    return new Float32Array(this.memory.buffer, e, this.dimensions);
   }
   /**
    * Write a vector to a specific slot in the database region.
    */
-  writeVector(e, t) {
-    const s = this.dbOffset + e * this.dimensions * 4;
-    new Float32Array(this.memory.buffer, s, this.dimensions).set(t);
+  writeVector(A, e) {
+    const s = this.dbOffset + A * this.dimensions * 4;
+    new Float32Array(this.memory.buffer, s, this.dimensions).set(e);
   }
   /**
    * Reset the vector count to zero, logically clearing the database.
@@ -194,55 +194,56 @@ class p {
     this._vectorCount = 0;
   }
 }
-function x(a, e, t) {
-  const s = a.length;
-  if (s === 0) return [];
-  const r = new Uint32Array(s);
-  for (let o = 0; o < s; o++) r[o] = o;
-  r.sort((o, A) => a[A] - a[o]);
-  const n = Math.min(t, s), i = new Array(n);
-  for (let o = 0; o < n; o++) {
-    const A = r[o];
-    i[o] = { key: e(A), score: a[A] };
-  }
-  return i;
+function G(n, A, e, s) {
+  const t = n.length;
+  if (t === 0) return [];
+  const r = new Uint32Array(t);
+  for (let i = 0; i < t; i++) r[i] = i;
+  r.sort((i, c) => n[c] - n[i]);
+  const o = Math.min(e, t), a = [];
+  for (let i = 0; i < o; i++) {
+    const c = r[i], h = 1 - n[c];
+    if (s !== void 0 && h > s) break;
+    a.push({ key: A(c), distance: h });
+  }
+  return a;
 }
-function v(a, e, t) {
-  const s = a.length;
-  if (s === 0) return [];
-  const r = new Uint32Array(s);
-  for (let i = 0; i < s; i++) r[i] = i;
-  r.sort((i, o) => a[o] - a[i]);
-  const n = Math.min(t, s);
+function x(n, A, e, s) {
+  const t = n.length;
+  if (t === 0) return [];
+  const r = new Uint32Array(t);
+  for (let a = 0; a < t; a++) r[a] = a;
+  r.sort((a, i) => n[i] - n[a]);
+  const o = Math.min(e, t);
   return {
     [Symbol.iterator]() {
-      let i = 0;
+      let a = 0;
       return {
         next() {
-          if (i >= n) return { done: !0, value: void 0 };
-          const o = r[i++];
-          return {
+          if (a >= o) return { done: !0, value: void 0 };
+          const i = r[a++], c = 1 - n[i];
+          return s !== void 0 && c > s ? { done: !0, value: void 0 } : {
             done: !1,
-            value: { key: e(o), score: a[o] }
+            value: { key: A(i), distance: c }
           };
         }
       };
     }
   };
 }
-const k = "AGFzbQEAAAABDgJgAn9/AGAFf39/f38AAg8BA2VudgZtZW1vcnkCAAEDAwIAAQcaAglub3JtYWxpemUAAApzZWFyY2hfYWxsAAEKsgQCtQIFAX8BewN9AXsDf/0MAAAAAAAAAAAAAAAAAAAAACEDIAFBfHEhCEEAIQICQANAIAIgCE8NASAAIAJBAnRqIQogAyAK/QAEACAK/QAEAP3mAf3kASEDIAJBBGohAgwACwsgA/0fACAD/R8BkiAD/R8CIAP9HwOSkiEEIAghCQJAA0AgCSABTw0BIAAgCUECdGohCiAEIAoqAgAgCioCAJSSIQQgCUEBaiEJDAALCyAEkSEFIAVDAAAAAFsEQA8LQwAAgD8gBZUhBiAG/RMhB0EAIQICQANAIAIgCE8NASAAIAJBAnRqIQogCiAK/QAEACAH/eYB/QsEACACQQRqIQIMAAsLIAghCQJAA0AgCSABTw0BIAAgCUECdGohCiAKIAoqAgAgBpQ4AgAgCUEBaiEJDAALCwv4AQQCfwF7AX0GfyAEQXxxIQogBEECdCEOQQAhBQJAA0AgBSADTw0BIAEgBSAObGohCf0MAAAAAAAAAAAAAAAAAAAAACEHQQAhBgJAA0AgBiAKTw0BIAAgBkECdGohDCAJIAZBAnRqIQ0gByAM/QAEACAN/QAEAP3mAf3kASEHIAZBBGohBgwACwsgB/0fACAH/R8BkiAH/R8CIAf9HwOSkiEIIAohCwJAA0AgCyAETw0BIAAgC0ECdGohDCAJIAtBAnRqIQ0gCCAMKgIAIA0qAgCUkiEIIAtBAWohCwwACwsgAiAFQQJ0aiAIOAIAIAVBAWohBQwACwsL";
-function F() {
-  const a = atob(k), e = new Uint8Array(a.length);
-  for (let t = 0; t < a.length; t++)
-    e[t] = a.charCodeAt(t);
-  return e;
+const H = "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";
+function p() {
+  const n = atob(H), A = new Uint8Array(n.length);
+  for (let e = 0; e < n.length; e++)
+    A[e] = n.charCodeAt(e);
+  return A;
 }
-async function V(a, e) {
-  const t = { env: { memory: e } };
-  return (await WebAssembly.instantiate(a, t)).instance.exports;
+async function F(n, A) {
+  const e = { env: { memory: A } };
+  return (await WebAssembly.instantiate(n, e)).instance.exports;
 }
-const u = "vectors.bin", w = "keys.bin";
-class C {
+const B = "vectors.bin", I = "keys.bin";
+class w {
   memoryManager;
   storage;
   dimensions;
@@ -254,23 +255,23 @@ class C {
   slotToKey;
   /** Whether this instance has been closed */
   closed = !1;
-  constructor(e, t, s, r, n, i, o) {
-    this.memoryManager = e, this.storage = t, this.dimensions = s, this.shouldNormalize = r, this.wasmExports = n, this.keyToSlot = i, this.slotToKey = o;
-  }
-  static async open(e) {
-    const t = e.name ?? "default", s = e.storage ?? new E(t), r = e.normalize !== !1, [n, i] = await Promise.all([s.readAll(u), s.readAll(w)]), o = i.byteLength > 0 ? O(i) : [], A = n.byteLength / (e.dimensions * 4), m = /* @__PURE__ */ new Map(), f = [];
-    for (let c = 0; c < o.length; c++)
-      m.set(o[c], c), f[c] = o[c];
-    const h = new p(e.dimensions, A);
-    n.byteLength > 0 && h.loadVectorBytes(n, A);
-    let l = null;
-    const g = e.wasmBinary !== void 0 ? e.wasmBinary : F();
-    if (g !== null)
+  constructor(A, e, s, t, r, o, a) {
+    this.memoryManager = A, this.storage = e, this.dimensions = s, this.shouldNormalize = t, this.wasmExports = r, this.keyToSlot = o, this.slotToKey = a;
+  }
+  static async open(A) {
+    const e = A.name ?? "default", s = A.storage ?? new C(e), t = A.normalize !== !1, [r, o] = await Promise.all([s.readAll(B), s.readAll(I)]), a = o.byteLength > 0 ? k(o) : [], i = r.byteLength / (A.dimensions * 4), c = /* @__PURE__ */ new Map(), h = [];
+    for (let g = 0; g < a.length; g++)
+      c.set(a[g], g), h[g] = a[g];
+    const y = new v(A.dimensions, i);
+    r.byteLength > 0 && y.loadVectorBytes(r, i);
+    let m = null;
+    const l = A.wasmBinary !== void 0 ? A.wasmBinary : p();
+    if (l !== null)
       try {
-        l = await V(g, h.memory);
+        m = await F(l, y.memory);
       } catch {
       }
-    return new C(h, s, e.dimensions, r, l, m, f);
+    return new w(y, s, A.dimensions, t, m, c, h);
   }
   /** Total number of key-value pairs in the database */
   get size() {
@@ -280,61 +281,61 @@ class C {
    * Set a key-value pair. If the key already exists, its vector is overwritten (last-write-wins).
    * The value is a number[] or Float32Array of length equal to the configured dimensions.
    */
-  set(e, t, s) {
-    if (this.assertOpen(), t.length !== this.dimensions)
-      throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${t.length}`);
-    const r = new Float32Array(t);
-    (s?.normalize ?? this.shouldNormalize) && this.normalizeVector(r);
-    const i = this.keyToSlot.get(e);
-    if (i !== void 0)
-      this.memoryManager.writeVector(i, r);
+  set(A, e, s) {
+    if (this.assertOpen(), e.length !== this.dimensions)
+      throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${e.length}`);
+    const t = new Float32Array(e);
+    (s?.normalize ?? this.shouldNormalize) && this.normalizeVector(t);
+    const o = this.keyToSlot.get(A);
+    if (o !== void 0)
+      this.memoryManager.writeVector(o, t);
     else {
       if (this.memoryManager.vectorCount + 1 > this.memoryManager.maxVectors)
-        throw new b(this.memoryManager.maxVectors);
+        throw new Q(this.memoryManager.maxVectors);
       this.memoryManager.ensureCapacity(1);
-      const A = this.memoryManager.vectorCount;
-      this.memoryManager.appendVectors([r]), this.keyToSlot.set(e, A), this.slotToKey[A] = e;
+      const i = this.memoryManager.vectorCount;
+      this.memoryManager.appendVectors([t]), this.keyToSlot.set(A, i), this.slotToKey[i] = A;
     }
   }
   /**
    * Get the stored vector for a key. Returns undefined if the key does not exist.
    * Returns a copy of the stored vector as a plain number array.
    */
-  get(e) {
+  get(A) {
     this.assertOpen();
-    const t = this.keyToSlot.get(e);
-    if (t !== void 0)
-      return Array.from(this.memoryManager.readVector(t));
+    const e = this.keyToSlot.get(A);
+    if (e !== void 0)
+      return Array.from(this.memoryManager.readVector(e));
   }
   /**
    * Set multiple key-value pairs at once. Last-write-wins applies within the batch.
    */
-  setMany(e) {
-    for (const [t, s] of e)
-      this.set(t, s);
+  setMany(A) {
+    for (const [e, s] of A)
+      this.set(e, s);
   }
   /**
    * Get vectors for multiple keys. Returns undefined for keys that don't exist.
    */
-  getMany(e) {
-    return e.map((t) => this.get(t));
+  getMany(A) {
+    return A.map((e) => this.get(e));
   }
-  query(e, t) {
+  query(A, e) {
     this.assertOpen();
-    const s = t?.topK ?? this.size, r = t && "iterable" in t && t.iterable;
+    const s = e?.topK ?? 1 / 0, t = e?.maxDistance, r = e && "iterable" in e && e.iterable;
     if (this.size === 0)
       return [];
-    if (e.length !== this.dimensions)
-      throw new Error(`Query vector dimension mismatch: expected ${this.dimensions}, got ${e.length}`);
-    const n = new Float32Array(e);
-    (t?.normalize ?? this.shouldNormalize) && this.normalizeVector(n), this.memoryManager.writeQuery(n), this.memoryManager.ensureCapacity(0);
-    const o = this.memoryManager.vectorCount, A = this.memoryManager.scoresOffset;
+    if (A.length !== this.dimensions)
+      throw new Error(`Query vector dimension mismatch: expected ${this.dimensions}, got ${A.length}`);
+    const o = new Float32Array(A);
+    (e?.normalize ?? this.shouldNormalize) && this.normalizeVector(o), this.memoryManager.writeQuery(o), this.memoryManager.ensureCapacity(0);
+    const i = this.memoryManager.vectorCount, c = this.memoryManager.scoresOffset;
     if (this.wasmExports)
       this.wasmExports.search_all(
         this.memoryManager.queryOffset,
         this.memoryManager.dbOffset,
-        A,
-        o,
+        c,
+        i,
         this.dimensions
       );
     else {
@@ -345,29 +346,29 @@ class C {
       ), g = new Float32Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        o * this.dimensions
-      ), c = new Float32Array(this.memoryManager.memory.buffer, A, o);
-      M(l, g, c, o, this.dimensions);
+        i * this.dimensions
+      ), u = new Float32Array(this.memoryManager.memory.buffer, c, i);
+      b(l, g, u, i, this.dimensions);
     }
-    const m = new Float32Array(this.memoryManager.readScores()), f = this.slotToKey, h = (l) => f[l];
-    return r ? v(m, h, s) : x(m, h, s);
+    const h = new Float32Array(this.memoryManager.readScores()), y = this.slotToKey, m = (l) => y[l];
+    return r ? x(h, m, s, t) : G(h, m, s, t);
   }
   /**
    * Persist the current in-memory state to storage.
    */
   async flush() {
     this.assertOpen();
-    const e = this.memoryManager.vectorCount, t = new Uint8Array(e * this.dimensions * 4);
-    if (e > 0) {
-      const r = new Uint8Array(
+    const A = this.memoryManager.vectorCount, e = new Uint8Array(A * this.dimensions * 4);
+    if (A > 0) {
+      const t = new Uint8Array(
         this.memoryManager.memory.buffer,
         this.memoryManager.dbOffset,
-        e * this.dimensions * 4
+        A * this.dimensions * 4
       );
-      t.set(r);
+      e.set(t);
     }
     const s = S(this.slotToKey);
-    await Promise.all([this.storage.write(u, t), this.storage.write(w, s)]);
+    await Promise.all([this.storage.write(B, e), this.storage.write(I, s)]);
   }
   /**
    * Flush data to storage and release the instance.
@@ -385,14 +386,14 @@ class C {
   /**
    * Normalize a vector using WASM (if available) or JS fallback.
    */
-  normalizeVector(e) {
+  normalizeVector(A) {
     if (this.wasmExports) {
-      const t = this.memoryManager.queryOffset;
-      new Float32Array(this.memoryManager.memory.buffer, t, e.length).set(e), this.wasmExports.normalize(t, e.length);
-      const s = new Float32Array(this.memoryManager.memory.buffer, t, e.length);
-      e.set(s);
+      const e = this.memoryManager.queryOffset;
+      new Float32Array(this.memoryManager.memory.buffer, e, A.length).set(A), this.wasmExports.normalize(e, A.length);
+      const s = new Float32Array(this.memoryManager.memory.buffer, e, A.length);
+      A.set(s);
     } else
-      B(e);
+      E(A);
   }
   assertOpen() {
     if (this.closed)
@@ -400,9 +401,9 @@ class C {
   }
 }
 export {
-  C as DB,
-  D as InMemoryStorageProvider,
-  E as OPFSStorageProvider,
-  b as VectorCapacityExceededError
+  w as DB,
+  O as InMemoryStorageProvider,
+  C as OPFSStorageProvider,
+  Q as VectorCapacityExceededError
 };
 //# sourceMappingURL=eigen-db.js.map