@aztec/kv-store 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/dest/sqlite-opfs/array.js

@@ -0,0 +1,128 @@
+var _computedKey;
+import { Encoder } from '#msgpackr';
+import { toBufferKey } from '#ordered-binary';
+import { hash } from 'ohash';
+_computedKey = Symbol.asyncIterator;
+/**
+ * Persistent array backed by SQLite. Entries share a common `key` (the array name)
+ * and are ordered by `key_count`, which doubles as the 1-indexed slot number.
+ */ export class SQLiteOPFSAztecArray {
+    store;
+    #name;
+    #container;
+    #encoder;
+    constructor(store, name){
+        this.store = store;
+        this.#encoder = new Encoder();
+        this.#name = name;
+        this.#container = `array:${name}`;
+    }
+    async lengthAsync() {
+        const rows = await this.store.allAsync('SELECT COUNT(*) FROM data WHERE container = ? AND key = ?', [
+            this.#container,
+            this.#encodedKey()
+        ]);
+        return Number(rows[0]?.[0] ?? 0);
+    }
+    async push(...vals) {
+        if (vals.length === 0) {
+            return this.lengthAsync();
+        }
+        return await this.store.transactionAsync(async ()=>{
+            let length = await this.lengthAsync();
+            for (const val of vals){
+                await this.store.runAsync(`INSERT INTO data (slot, container, key, key_count, hash, value)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+                    this.#slot(length),
+                    this.#container,
+                    this.#encodedKey(),
+                    length + 1,
+                    hash(val),
+                    this.#encoder.pack(val)
+                ]);
+                length += 1;
+            }
+            return length;
+        });
+    }
+    async pop() {
+        return await this.store.transactionAsync(async ()=>{
+            const length = await this.lengthAsync();
+            if (length === 0) {
+                return undefined;
+            }
+            const slot = this.#slot(length - 1);
+            const rows = await this.store.allAsync('SELECT value FROM data WHERE slot = ? LIMIT 1', [
+                slot
+            ]);
+            await this.store.runAsync('DELETE FROM data WHERE slot = ?', [
+                slot
+            ]);
+            const raw = rows[0]?.[0];
+            return raw instanceof Uint8Array ? this.#encoder.unpack(raw) : undefined;
+        });
+    }
+    async atAsync(index) {
+        const length = await this.lengthAsync();
+        const resolved = index < 0 ? length + index : index;
+        if (resolved < 0 || resolved >= length) {
+            return undefined;
+        }
+        const rows = await this.store.allAsync('SELECT value FROM data WHERE slot = ? LIMIT 1', [
+            this.#slot(resolved)
+        ]);
+        const raw = rows[0]?.[0];
+        return raw instanceof Uint8Array ? this.#encoder.unpack(raw) : undefined;
+    }
+    async setAt(index, val) {
+        return await this.store.transactionAsync(async ()=>{
+            const length = await this.lengthAsync();
+            const resolved = index < 0 ? length + index : index;
+            if (resolved < 0 || resolved >= length) {
+                return false;
+            }
+            await this.store.runAsync(`INSERT OR REPLACE INTO data (slot, container, key, key_count, hash, value)
+         VALUES (?, ?, ?, ?, ?, ?)`, [
+                this.#slot(resolved),
+                this.#container,
+                this.#encodedKey(),
+                resolved + 1,
+                hash(val),
+                this.#encoder.pack(val)
+            ]);
+            return true;
+        });
+    }
+    async *entriesAsync() {
+        const rows = await this.store.allAsync('SELECT key_count, value FROM data WHERE container = ? AND key = ? ORDER BY key_count ASC', [
+            this.#container,
+            this.#encodedKey()
+        ]);
+        for (const row of rows){
+            const keyCount = Number(row[0]);
+            const raw = row[1];
+            if (raw instanceof Uint8Array) {
+                yield [
+                    keyCount - 1,
+                    this.#encoder.unpack(raw)
+                ];
+            }
+        }
+    }
+    async *valuesAsync() {
+        for await (const [, val] of this.entriesAsync()){
+            yield val;
+        }
+    }
+    [_computedKey]() {
+        return this.valuesAsync();
+    }
+    #encodedKey() {
+        return toBufferKey([
+            this.#name
+        ]);
+    }
+    #slot(index) {
+        return `array:${this.#name}:slot:${index}`;
+    }
+}

package/dest/sqlite-opfs/errors.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Typed error surface for sqlite3mc-backed page-level encryption failures.
+ *
+ * Three concrete failure modes are surfaced:
+ *
+ *   - `invalid_key_length`: caller-side pre-flight (key not 32 bytes).
+ *   - `encryption_not_supported_for_ephemeral`: caller-side pre-flight (encryption was requested on an ephemeral
+ *     `:memory:` store, which sqlite3mc does not support).
+ *   - `decrypt_failed`: runtime failure raised when sqlite3mc cannot decode page 1 of an existing database. Covers
+ *     both "wrong key supplied" and "no key supplied to an encrypted DB".
+ */
+export type SqliteEncryptionErrorCode = 'invalid_key_length' | 'encryption_not_supported_for_ephemeral' | 'decrypt_failed';
+/**
+ * Error thrown by sqlite-opfs when an encryption operation fails.
+ **/
+export declare class SqliteEncryptionError extends Error {
+    readonly code: SqliteEncryptionErrorCode;
+    constructor(code: SqliteEncryptionErrorCode, message: string, opts?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Returns `true` if `message` matches one of the known sqlite3mc decrypt-failure
+ * strings.
+ **/
+export declare function isDecryptFailureMessage(message: string): boolean;
+/**
+ * Error thrown by sqlite-opfs when the on-disk database image is corrupt
+ * (`SQLITE_CORRUPT`, result code 11 — "database disk image is malformed").
+ *
+ * Distinct from {@link SqliteEncryptionError}: no key recovers a corrupt image,
+ * so there is nothing to retry. The only escape is to delete the store and start
+ * fresh, so consumers pattern-match on `instanceof SqliteCorruptionError` to wipe
+ * and reopen rather than surfacing a dead-end error.
+ **/
+export declare class SqliteCorruptionError extends Error {
+    constructor(message: string, opts?: {
+        cause?: unknown;
+    });
+}
+/** Error thrown when another browser context already owns a store's OPFS pool. */
+export declare class SqlitePoolBusyError extends Error {
+    readonly poolDirectory: string;
+    constructor(poolDirectory: string);
+}
+/** Error thrown when the browser context does not expose the Web Locks API required by the OPFS SAH pool. */
+export declare class SqliteWebLocksUnavailableError extends Error {
+    constructor();
+}
+/**
+ * Returns `true` if `message` matches one of the known SQLite corruption strings.
+ **/
+export declare function isCorruptionMessage(message: string): boolean;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLE1BQU0seUJBQXlCLEdBQ2pDLG9CQUFvQixHQUNwQix3Q0FBd0MsR0FDeEMsZ0JBQWdCLENBQUM7QUFFckI7O0lBRUk7QUFDSixxQkFBYSxxQkFBc0IsU0FBUSxLQUFLO0lBQzlDLFFBQVEsQ0FBQyxJQUFJLEVBQUUseUJBQXlCLENBQUM7SUFFekMsWUFBWSxJQUFJLEVBQUUseUJBQXlCLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTtRQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sQ0FBQTtLQUFFLEVBSXZGO0NBQ0Y7QUFVRDs7O0lBR0k7QUFDSix3QkFBZ0IsdUJBQXVCLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBRWhFO0FBRUQ7Ozs7Ozs7O0lBUUk7QUFDSixxQkFBYSxxQkFBc0IsU0FBUSxLQUFLO0lBQzlDLFlBQVksT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsRUFBRTtRQUFFLEtBQUssQ0FBQyxFQUFFLE9BQU8sQ0FBQTtLQUFFLEVBR3REO0NBQ0Y7QUFFRCxrRkFBa0Y7QUFDbEYscUJBQWEsbUJBQW9CLFNBQVEsS0FBSzthQUNoQixhQUFhLEVBQUUsTUFBTTtJQUFqRCxZQUE0QixhQUFhLEVBQUUsTUFBTSxFQUdoRDtDQUNGO0FBRUQsNkdBQTZHO0FBQzdHLHFCQUFhLDhCQUErQixTQUFRLEtBQUs7SUFDdkQsY0FHQztDQUNGO0FBYUQ7O0lBRUk7QUFDSix3QkFBZ0IsbUJBQW1CLENBQUMsT0FBTyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBRTVEIn0=

package/dest/sqlite-opfs/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,yBAAyB,GACjC,oBAAoB,GACpB,wCAAwC,GACxC,gBAAgB,CAAC;AAErB;;IAEI;AACJ,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IAEzC,YAAY,IAAI,EAAE,yBAAyB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAIvF;CACF;AAUD;;;IAGI;AACJ,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;;;;IAQI;AACJ,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAGtD;CACF;AAED,kFAAkF;AAClF,qBAAa,mBAAoB,SAAQ,KAAK;aAChB,aAAa,EAAE,MAAM;IAAjD,YAA4B,aAAa,EAAE,MAAM,EAGhD;CACF;AAED,6GAA6G;AAC7G,qBAAa,8BAA+B,SAAQ,KAAK;IACvD,cAGC;CACF;AAaD;;IAEI;AACJ,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D"}

package/dest/sqlite-opfs/errors.js

@@ -0,0 +1,77 @@
+/**
+ * Typed error surface for sqlite3mc-backed page-level encryption failures.
+ *
+ * Three concrete failure modes are surfaced:
+ *
+ *   - `invalid_key_length`: caller-side pre-flight (key not 32 bytes).
+ *   - `encryption_not_supported_for_ephemeral`: caller-side pre-flight (encryption was requested on an ephemeral
+ *     `:memory:` store, which sqlite3mc does not support).
+ *   - `decrypt_failed`: runtime failure raised when sqlite3mc cannot decode page 1 of an existing database. Covers
+ *     both "wrong key supplied" and "no key supplied to an encrypted DB".
+ */ /**
+ * Error thrown by sqlite-opfs when an encryption operation fails.
+ **/ export class SqliteEncryptionError extends Error {
+    code;
+    constructor(code, message, opts){
+        super(message, opts?.cause !== undefined ? {
+            cause: opts.cause
+        } : undefined);
+        this.name = 'SqliteEncryptionError';
+        this.code = code;
+    }
+}
+/**
+ * Strings raised by sqlite3mc when page 1 cannot be decoded.
+ **/ const SQLITE3MC_DECRYPT_ERROR_PATTERNS = [
+    /file is not a database/i,
+    /file is encrypted or is not a database/i
+];
+/**
+ * Returns `true` if `message` matches one of the known sqlite3mc decrypt-failure
+ * strings.
+ **/ export function isDecryptFailureMessage(message) {
+    return SQLITE3MC_DECRYPT_ERROR_PATTERNS.some((p)=>p.test(message));
+}
+/**
+ * Error thrown by sqlite-opfs when the on-disk database image is corrupt
+ * (`SQLITE_CORRUPT`, result code 11 — "database disk image is malformed").
+ *
+ * Distinct from {@link SqliteEncryptionError}: no key recovers a corrupt image,
+ * so there is nothing to retry. The only escape is to delete the store and start
+ * fresh, so consumers pattern-match on `instanceof SqliteCorruptionError` to wipe
+ * and reopen rather than surfacing a dead-end error.
+ **/ export class SqliteCorruptionError extends Error {
+    constructor(message, opts){
+        super(message, opts?.cause !== undefined ? {
+            cause: opts.cause
+        } : undefined);
+        this.name = 'SqliteCorruptionError';
+    }
+}
+/** Error thrown when another browser context already owns a store's OPFS pool. */ export class SqlitePoolBusyError extends Error {
+    poolDirectory;
+    constructor(poolDirectory){
+        super(`SQLite-OPFS pool "${poolDirectory}" is already in use by another store instance`), this.poolDirectory = poolDirectory;
+        this.name = 'SqlitePoolBusyError';
+    }
+}
+/** Error thrown when the browser context does not expose the Web Locks API required by the OPFS SAH pool. */ export class SqliteWebLocksUnavailableError extends Error {
+    constructor(){
+        super('SQLite-OPFS requires the Web Locks API, but it is unavailable in this browser context');
+        this.name = 'SqliteWebLocksUnavailableError';
+    }
+}
+/**
+ * Strings/codes raised by SQLite when a database image is corrupt. Kept disjoint
+ * from {@link SQLITE3MC_DECRYPT_ERROR_PATTERNS}: "file is not a database"
+ * (SQLITE_NOTADB) is the decrypt signal, whereas a malformed image is the
+ * genuinely-unrecoverable SQLITE_CORRUPT.
+ **/ const SQLITE_CORRUPTION_ERROR_PATTERNS = [
+    /database disk image is malformed/i,
+    /\bSQLITE_CORRUPT\b/i
+];
+/**
+ * Returns `true` if `message` matches one of the known SQLite corruption strings.
+ **/ export function isCorruptionMessage(message) {
+    return SQLITE_CORRUPTION_ERROR_PATTERNS.some((p)=>p.test(message));
+}

package/dest/sqlite-opfs/index.d.ts

@@ -0,0 +1,14 @@
+import { AztecSQLiteOPFSStore } from './store.js';
+export { AztecSQLiteOPFSStore } from './store.js';
+export { SqliteCorruptionError, SqliteEncryptionError, SqlitePoolBusyError, SqliteWebLocksUnavailableError, } from './errors.js';
+export type { SqliteEncryptionErrorCode } from './errors.js';
+export { OPFS_POOL_DIR_PREFIX, deletePoolDirectory, deleteStore, listStores, storePoolDirectory } from './manage.js';
+export declare function openTmpStore(ephemeral?: boolean): Promise<AztecSQLiteOPFSStore>;
+/**
+ * Convenience helper for tests and consumers that want an encrypted sqlite-opfs
+ * store without dealing with the full `open()` parameter order. Key must be 32
+ * bytes. Creates a fresh persistent store (sqlite3mc does not support encryption
+ * on ephemeral `:memory:` databases) in an auto-generated OPFS directory.
+ */
+export declare function openEncryptedStore(encryptionKey: Uint8Array, name?: string, poolDirectory?: string): Promise<AztecSQLiteOPFSStore>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zcWxpdGUtb3Bmcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFbEQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ2xELE9BQU8sRUFDTCxxQkFBcUIsRUFDckIscUJBQXFCLEVBQ3JCLG1CQUFtQixFQUNuQiw4QkFBOEIsR0FDL0IsTUFBTSxhQUFhLENBQUM7QUFDckIsWUFBWSxFQUFFLHlCQUF5QixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzdELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxtQkFBbUIsRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLGtCQUFrQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXJILHdCQUFnQixZQUFZLENBQUMsU0FBUyxHQUFFLE9BQWUsR0FBRyxPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FFdEY7QUFFRDs7Ozs7R0FLRztBQUNILHdCQUFnQixrQkFBa0IsQ0FBQyxhQUFhLEVBQUUsVUFBVSxFQUFFLElBQUksQ0FBQyxFQUFFLE1BQU0sRUFBRSxhQUFhLENBQUMsRUFBRSxNQUFNLGlDQUVsRyJ9

package/dest/sqlite-opfs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,8BAA8B,GAC/B,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,WAAW,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAErH,wBAAgB,YAAY,CAAC,SAAS,GAAE,OAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAEtF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,iCAElG"}

package/dest/sqlite-opfs/index.js

@@ -0,0 +1,16 @@
+import { createLogger } from '@aztec/foundation/log';
+import { AztecSQLiteOPFSStore } from './store.js';
+export { AztecSQLiteOPFSStore } from './store.js';
+export { SqliteCorruptionError, SqliteEncryptionError, SqlitePoolBusyError, SqliteWebLocksUnavailableError } from './errors.js';
+export { OPFS_POOL_DIR_PREFIX, deletePoolDirectory, deleteStore, listStores, storePoolDirectory } from './manage.js';
+export function openTmpStore(ephemeral = false) {
+    return AztecSQLiteOPFSStore.open(createLogger('kv-store:sqlite-opfs'), undefined, ephemeral);
+}
+/**
+ * Convenience helper for tests and consumers that want an encrypted sqlite-opfs
+ * store without dealing with the full `open()` parameter order. Key must be 32
+ * bytes. Creates a fresh persistent store (sqlite3mc does not support encryption
+ * on ephemeral `:memory:` databases) in an auto-generated OPFS directory.
+ */ export function openEncryptedStore(encryptionKey, name, poolDirectory) {
+    return AztecSQLiteOPFSStore.open(createLogger('kv-store:sqlite-opfs'), name, false, poolDirectory, encryptionKey);
+}

package/dest/sqlite-opfs/internal/ordered-binary-browser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Vendored from `ordered-binary@1.5.3/index.js` with one targeted edit:
+ * the `readString` definition (originally a dynamically-generated
+ * unrolled-loop function) is replaced with a hand-written interpreted
+ * equivalent that does the same work without code-generation-from-strings.
+ *
+ * Why vendor: upstream has no CSP-safe build, and the codegen is a
+ * module-init-time string-passed-to-evaluator that trips MV3 CSP
+ * (`script-src 'self' 'wasm-unsafe-eval'`). The codegen is a perf
+ * optimization on the string-decoding path only — the interpreted
+ * version is functionally identical, just slower per call.
+ *
+ * Parity with upstream is enforced by `ordered-binary-browser.test.ts`,
+ * which compares byte-exact output for a representative key set on every
+ * Node-mode test run. If `ordered-binary` is bumped, re-vendor by
+ * recopying upstream and reapplying the patch in the section marked
+ * `// CSP PATCH BEGIN` ... `// CSP PATCH END`.
+ */
+export declare function writeKey(key: any, target: any, position: any, inSequence: any): any;
+export declare function readKey(buffer: any, start: any, end: any, inSequence: any): any;
+export declare const enableNullTermination: () => boolean;
+export declare const encoder: {
+    writeKey: typeof writeKey;
+    readKey: typeof readKey;
+    enableNullTermination: () => boolean;
+};
+export declare const toBufferKey: (key: any) => any;
+export declare const fromBufferKey: (sourceBuffer: any) => any;
+export declare function compareKeys(a: any, b: any): any;
+export declare const MINIMUM_KEY: null;
+export declare const MAXIMUM_KEY: Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXJlZC1iaW5hcnktYnJvd3Nlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3NxbGl0ZS1vcGZzL2ludGVybmFsL29yZGVyZWQtYmluYXJ5LWJyb3dzZXIuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBNEJILHdCQUFnQixRQUFRLENBQUMsR0FBRyxLQUFBLEVBQUUsTUFBTSxLQUFBLEVBQUUsUUFBUSxLQUFBLEVBQUUsVUFBVSxLQUFBLE9Bd0p6RDtBQUdELHdCQUFnQixPQUFPLENBQUMsTUFBTSxLQUFBLEVBQUUsS0FBSyxLQUFBLEVBQUUsR0FBRyxLQUFBLEVBQUUsVUFBVSxLQUFBLE9BK0ZyRDtBQUNELGVBQU8sTUFBTSxxQkFBcUIsZUFBK0IsQ0FBQztBQUVsRSxlQUFPLE1BQU0sT0FBTzs7OztDQUluQixDQUFDO0FBS0YsZUFBTyxNQUFNLFdBQVcsbUJBdUJ2QixDQUFDO0FBQ0YsZUFBTyxNQUFNLGFBQWEsNEJBRXpCLENBQUM7QUErRUYsd0JBQWdCLFdBQVcsQ0FBQyxDQUFDLEtBQUEsRUFBRSxDQUFDLEtBQUEsT0EwQy9CO0FBUUQsZUFBTyxNQUFNLFdBQVcsTUFBTyxDQUFDO0FBQ2hDLGVBQU8sTUFBTSxXQUFXLHlCQUF5QixDQUFDIn0=

package/dest/sqlite-opfs/internal/ordered-binary-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordered-binary-browser.d.ts","sourceRoot":"","sources":["../../../src/sqlite-opfs/internal/ordered-binary-browser.js"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AA4BH,wBAAgB,QAAQ,CAAC,GAAG,KAAA,EAAE,MAAM,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA,OAwJzD;AAGD,wBAAgB,OAAO,CAAC,MAAM,KAAA,EAAE,KAAK,KAAA,EAAE,GAAG,KAAA,EAAE,UAAU,KAAA,OA+FrD;AACD,eAAO,MAAM,qBAAqB,eAA+B,CAAC;AAElE,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAKF,eAAO,MAAM,WAAW,mBAuBvB,CAAC;AACF,eAAO,MAAM,aAAa,4BAEzB,CAAC;AA+EF,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OA0C/B;AAQD,eAAO,MAAM,WAAW,MAAO,CAAC;AAChC,eAAO,MAAM,WAAW,yBAAyB,CAAC"}