@evolu/sqlite-wasm 2.2.4 → 3.53.4-build1

package/dist/src/Memory.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Standalone helpers for wasm memory: allocation, UTF-8, bytes, scratch memory,
+ * and integer ranges.
+ *
+ * Like the CApi functions, each helper that touches the instance takes
+ * {@link SqliteWasmDep} and returns the operation, so a database binds it once.
+ *
+ * Rules the helpers follow and their callers must too:
+ *
+ * - Allocate at least one byte. `sqlite3_malloc(0)` returns NULL, and binding a
+ *   NULL address binds SQL NULL, so an empty string or blob would silently
+ *   become NULL.
+ * - Take the heap view after allocating. Growing memory detaches the previous
+ *   `ArrayBuffer`, and writing to a detached view does nothing.
+ * - Decode by byte length with a decoder that keeps a leading byte order mark, so
+ *   text round-trips exactly, including embedded NUL characters. The default
+ *   `TextDecoder` strips it.
+ *
+ * @module
+ */
+import { type Result, type Typed } from "@evolu/common";
+import type { CStringPtr, SqliteOwnedCStringPtr, SqliteOwnedPtr, WasmPtr } from "./Pointer.ts";
+import type { SqliteWasmDep } from "./Wasm.ts";
+/** `sqlite3_malloc` returned NULL. */
+export interface SqliteNoMemError extends Typed<"SqliteNoMem"> {
+    readonly byteLength: number;
+}
+/**
+ * Allocates at least one byte with `sqlite3_malloc`, so a zero-length value
+ * keeps a non-NULL address.
+ *
+ * A request above {@link maxInt32} fails without calling `sqlite3_malloc`, which
+ * takes a C int and would wrap it.
+ */
+export declare const allocWasm: (deps: SqliteWasmDep) => (byteLength: number) => Result<SqliteOwnedPtr, SqliteNoMemError>;
+/**
+ * Copies a string into new memory as a NUL-terminated UTF-8 C string, which the
+ * caller frees with `sqlite3_free`.
+ *
+ * UTF-8 cannot encode a lone surrogate, which becomes U+FFFD, as with
+ * `TextEncoder`, so a caller that needs the exact text checks
+ * `String.prototype.isWellFormed` first.
+ */
+export declare const allocCString: (deps: SqliteWasmDep) => (value: string) => Result<SqliteOwnedCStringPtr, SqliteNoMemError>;
+/**
+ * Encodes a string as UTF-8 into existing memory and returns the byte length,
+ * without a NUL terminator.
+ *
+ * The memory needs up to three bytes per UTF-16 code unit; text that does not
+ * fit is cut at a character boundary, so reserve `value.length * 3` bytes. A
+ * lone surrogate becomes U+FFFD, as in {@link allocCString}.
+ */
+export declare const writeUtf8: (deps: SqliteWasmDep) => (value: string, ptr: WasmPtr, capacity: number) => number;
+/** Decodes a NUL-terminated C string, such as an error message or a column name. */
+export declare const readCString: (deps: SqliteWasmDep) => (ptr: CStringPtr) => string;
+/**
+ * Decodes UTF-8 of a known byte length, such as a text column, keeping a
+ * leading byte order mark and embedded NUL characters.
+ */
+export declare const readUtf8: (deps: SqliteWasmDep) => (ptr: WasmPtr, byteLength: number) => string;
+/**
+ * Copies bytes out of wasm memory into a new `ArrayBuffer`, so the result can
+ * be transferred to another worker.
+ */
+export declare const copyWasmBytes: (deps: SqliteWasmDep) => (ptr: WasmPtr, byteLength: number) => Uint8Array<ArrayBuffer>;
+/** Copies bytes into wasm memory. */
+export declare const writeWasmBytes: (deps: SqliteWasmDep) => (ptr: WasmPtr, bytes: Uint8Array) => void;
+/**
+ * Reusable memory for output parameters and bind values, allocated once per
+ * database instead of once per call.
+ *
+ * A callback inside a call, such as a collation-needed callback or a trace
+ * callback, can run another call on the same database, which reuses this
+ * memory. The outer call is unaffected, because SQLite copies a value bound
+ * with SQLITE_TRANSIENT at once and writes an output parameter after the
+ * callbacks of the call. What SQLite reads or writes before a callback and the
+ * caller uses after it needs memory of its own: SQL, which SQLite parses in
+ * place and copies only after the parse, and the size `sqlite3_serialize`
+ * writes before it finalizes its query.
+ */
+export interface SqliteScratch extends Disposable {
+    /**
+     * Sixteen bytes, 8-byte aligned, for output parameters such as `ppDb`,
+     * `ppStmt` and `pzTail`.
+     */
+    readonly out: WasmPtr;
+    /**
+     * Returns memory of at least the given length, growing it when needed. The
+     * previous contents are not kept, and the address is valid until the next
+     * call. Growth doubles the capacity, so reallocations stay rare as values
+     * grow, or, when that much memory is not available, allocates the length
+     * alone. A failure leaves the scratch empty, so later calls are unaffected.
+     *
+     * Binding text or a blob from here with SQLITE_TRANSIENT is faster than
+     * allocating per value: SQLite copies into a buffer it reuses.
+     */
+    readonly reserve: (byteLength: number) => Result<WasmPtr, SqliteNoMemError>;
+}
+/** Creates a {@link SqliteScratch}. */
+export declare const createSqliteScratch: (deps: SqliteWasmDep) => Result<SqliteScratch, SqliteNoMemError>;
+/** The largest C int. */
+export declare const maxInt32 = 2147483647;
+/**
+ * Whether a number is a 32-bit integer, which binds with `sqlite3_bind_int`
+ * without a BigInt.
+ */
+export declare const isInt32: (value: number) => boolean;
+/** The largest SQLite INTEGER, 2^63 - 1. */
+export declare const maxSqliteInt64: bigint;
+/** The smallest SQLite INTEGER, -2^63. */
+export declare const minSqliteInt64: bigint;
+/**
+ * Whether a bigint fits a SQLite INTEGER.
+ *
+ * The wasm boundary converts a bigint to i64 modulo 2^64 without an error, so
+ * anything passed to `sqlite3_bind_int64` must be checked first.
+ */
+export declare const isSqliteInt64: (value: bigint) => boolean;
+//# sourceMappingURL=Memory.d.ts.map

package/dist/src/Memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memory.d.ts","sourceRoot":"","sources":["../../src/Memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAuB,KAAK,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,KAAK,EACV,UAAU,EACV,qBAAqB,EACrB,cAAc,EACd,OAAO,EACR,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAO/C,sCAAsC;AACtC,MAAM,WAAW,gBAAiB,SAAQ,KAAK,CAAC,aAAa,CAAC;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,SACb,aAAa,kBACP,MAAM,KAAG,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAM5D,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,SAChB,aAAa,aACZ,MAAM,KAAG,MAAM,CAAC,qBAAqB,EAAE,gBAAgB,CAS9D,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,SACb,aAAa,aACZ,MAAM,OAAO,OAAO,YAAY,MAAM,KAAG,MAItC,CAAC;AAEd,oFAAoF;AACpF,eAAO,MAAM,WAAW,SACf,aAAa,WACd,UAAU,KAAG,MAGlB,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,QAAQ,SACZ,aAAa,WACd,OAAO,cAAc,MAAM,KAAG,MAGjC,CAAC;AAEN;;;GAGG;AACH,eAAO,MAAM,aAAa,SACjB,aAAa,WACd,OAAO,cAAc,MAAM,KAAG,UAAU,CAAC,WAAW,CACA,CAAC;AAE7D,qCAAqC;AACrC,eAAO,MAAM,cAAc,SAClB,aAAa,WACd,OAAO,SAAS,UAAU,KAAG,IAElC,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IAEtB;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;CAC7E;AAED,uCAAuC;AACvC,eAAO,MAAM,mBAAmB,SACxB,aAAa,KAClB,MAAM,CAAC,aAAa,EAAE,gBAAgB,CA8CxC,CAAC;AAEF,yBAAyB;AACzB,eAAO,MAAM,QAAQ,aAAc,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,OAAO,UAAW,MAAM,KAAG,OACgC,CAAC;AAEzE,4CAA4C;AAC5C,eAAO,MAAM,cAAc,QAAiB,CAAC;AAE7C,0CAA0C;AAC1C,eAAO,MAAM,cAAc,QAAe,CAAC;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,OACV,CAAC"}

package/dist/src/Memory.js

@@ -0,0 +1,207 @@
+/**
+ * Standalone helpers for wasm memory: allocation, UTF-8, bytes, scratch memory,
+ * and integer ranges.
+ *
+ * Like the CApi functions, each helper that touches the instance takes
+ * {@link SqliteWasmDep} and returns the operation, so a database binds it once.
+ *
+ * Rules the helpers follow and their callers must too:
+ *
+ * - Allocate at least one byte. `sqlite3_malloc(0)` returns NULL, and binding a
+ *   NULL address binds SQL NULL, so an empty string or blob would silently
+ *   become NULL.
+ * - Take the heap view after allocating. Growing memory detaches the previous
+ *   `ArrayBuffer`, and writing to a detached view does nothing.
+ * - Decode by byte length with a decoder that keeps a leading byte order mark, so
+ *   text round-trips exactly, including embedded NUL characters. The default
+ *   `TextDecoder` strips it.
+ *
+ * @module
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { disposable, err, ok } from "@evolu/common";
+const utf8Encoder = /*#__PURE__*/ new TextEncoder();
+// Keeps a leading byte order mark, which the default decoder strips.
+const utf8Decoder = /*#__PURE__*/ new TextDecoder("utf-8", { ignoreBOM: true });
+/**
+ * Allocates at least one byte with `sqlite3_malloc`, so a zero-length value
+ * keeps a non-NULL address.
+ *
+ * A request above {@link maxInt32} fails without calling `sqlite3_malloc`, which
+ * takes a C int and would wrap it.
+ */
+export const allocWasm = (deps) => (byteLength) => {
+    const ptr = byteLength > maxInt32
+        ? 0
+        : deps.sqliteWasm.exports.sqlite3_malloc(Math.max(1, byteLength));
+    return ptr === 0 ? err({ type: "SqliteNoMem", byteLength }) : ok(ptr);
+};
+/**
+ * Copies a string into new memory as a NUL-terminated UTF-8 C string, which the
+ * caller frees with `sqlite3_free`.
+ *
+ * UTF-8 cannot encode a lone surrogate, which becomes U+FFFD, as with
+ * `TextEncoder`, so a caller that needs the exact text checks
+ * `String.prototype.isWellFormed` first.
+ */
+export const allocCString = (deps) => (value) => {
+    const bytes = utf8Encoder.encode(value);
+    const allocated = allocWasm(deps)(bytes.length + 1);
+    if (!allocated.ok)
+        return allocated;
+    const ptr = allocated.value;
+    const heap = deps.sqliteWasm.getHeapU8();
+    heap.set(bytes, ptr);
+    heap[ptr + bytes.length] = 0;
+    return ok(ptr);
+};
+/**
+ * Encodes a string as UTF-8 into existing memory and returns the byte length,
+ * without a NUL terminator.
+ *
+ * The memory needs up to three bytes per UTF-16 code unit; text that does not
+ * fit is cut at a character boundary, so reserve `value.length * 3` bytes. A
+ * lone surrogate becomes U+FFFD, as in {@link allocCString}.
+ */
+export const writeUtf8 = (deps) => (value, ptr, capacity) => utf8Encoder.encodeInto(value, deps.sqliteWasm.getHeapU8().subarray(ptr, ptr + capacity)).written;
+/** Decodes a NUL-terminated C string, such as an error message or a column name. */
+export const readCString = (deps) => (ptr) => {
+    const heap = deps.sqliteWasm.getHeapU8();
+    return utf8Decoder.decode(heap.subarray(ptr, heap.indexOf(0, ptr)));
+};
+/**
+ * Decodes UTF-8 of a known byte length, such as a text column, keeping a
+ * leading byte order mark and embedded NUL characters.
+ */
+export const readUtf8 = (deps) => (ptr, byteLength) => utf8Decoder.decode(deps.sqliteWasm.getHeapU8().subarray(ptr, ptr + byteLength));
+/**
+ * Copies bytes out of wasm memory into a new `ArrayBuffer`, so the result can
+ * be transferred to another worker.
+ */
+export const copyWasmBytes = (deps) => (ptr, byteLength) => deps.sqliteWasm.getHeapU8().slice(ptr, ptr + byteLength);
+/** Copies bytes into wasm memory. */
+export const writeWasmBytes = (deps) => (ptr, bytes) => {
+    deps.sqliteWasm.getHeapU8().set(bytes, ptr);
+};
+/** Creates a {@link SqliteScratch}. */
+export const createSqliteScratch = (deps) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const out = allocWasm(deps)(16);
+        if (!out.ok)
+            return out;
+        let buffer = null;
+        let capacity = 0;
+        const disposer = __addDisposableResource(env_1, new DisposableStack(), false);
+        disposer.defer(() => {
+            deps.sqliteWasm.exports.sqlite3_free(out.value);
+        });
+        disposer.defer(() => {
+            if (buffer != null)
+                deps.sqliteWasm.exports.sqlite3_free(buffer);
+        });
+        return ok(disposable({
+            out: out.value,
+            reserve: (byteLength) => {
+                if (buffer != null) {
+                    if (byteLength <= capacity)
+                        return ok(buffer);
+                    // The contents need not be kept, so the old memory goes first.
+                    deps.sqliteWasm.exports.sqlite3_free(buffer);
+                    buffer = null;
+                }
+                // Twice the capacity keeps reallocations rare, but when it is not
+                // available, the requested length alone may still be.
+                let newCapacity = Math.max(byteLength, capacity * 2);
+                let allocated = allocWasm(deps)(newCapacity);
+                if (!allocated.ok && newCapacity > byteLength) {
+                    newCapacity = byteLength;
+                    allocated = allocWasm(deps)(newCapacity);
+                }
+                if (!allocated.ok) {
+                    capacity = 0;
+                    return allocated;
+                }
+                buffer = allocated.value;
+                capacity = newCapacity;
+                return ok(buffer);
+            },
+        }, disposer));
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+};
+/** The largest C int. */
+export const maxInt32 = 0x7fff_ffff;
+/**
+ * Whether a number is a 32-bit integer, which binds with `sqlite3_bind_int`
+ * without a BigInt.
+ */
+export const isInt32 = (value) => Number.isInteger(value) && value >= -maxInt32 - 1 && value <= maxInt32;
+/** The largest SQLite INTEGER, 2^63 - 1. */
+export const maxSqliteInt64 = 2n ** 63n - 1n;
+/** The smallest SQLite INTEGER, -2^63. */
+export const minSqliteInt64 = -(2n ** 63n);
+/**
+ * Whether a bigint fits a SQLite INTEGER.
+ *
+ * The wasm boundary converts a bigint to i64 modulo 2^64 without an error, so
+ * anything passed to `sqlite3_bind_int64` must be checked first.
+ */
+export const isSqliteInt64 = (value) => BigInt.asIntN(64, value) === value;

package/dist/src/Pointer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Branded pointers into SQLite's wasm memory and function table.
+ *
+ * At runtime every pointer is a wasm32 address, a plain number. The brands keep
+ * C types apart, so a statement cannot be passed where a connection is
+ * expected, borrowed memory cannot be freed, and no JavaScript string converts
+ * to a C string implicitly. Only this package creates pointer values, from what
+ * the wasm returns.
+ *
+ * The loader caps memory at 2 GiB (32768 pages), so every address is a
+ * non-negative i32 and reads with `getUint32` need no `>>> 0`.
+ *
+ * @module
+ */
+import type { Brand } from "@evolu/common";
+import type { SQLITE_STATIC, SQLITE_TRANSIENT } from "./Constants.ts";
+/** An address in the wasm heap. */
+export type WasmPtr = number & Brand<"WasmPtr">;
+/**
+ * The C NULL pointer.
+ *
+ * Functions that can return NULL include it in their result type, and a `=== 0`
+ * check narrows it away.
+ */
+export type NullPtr = 0;
+/**
+ * A NUL-terminated UTF-8 string.
+ *
+ * Returned C strings are borrowed from SQLite: copy them before the next call
+ * on the same object and never free them.
+ */
+export type CStringPtr = WasmPtr & Brand<"CString">;
+/**
+ * Memory allocated with `sqlite3_malloc`.
+ *
+ * The holder frees it with `sqlite3_free` or hands it to SQLite, for example as
+ * a bind value with {@link SQLITE_WASM_DEALLOC}.
+ */
+export type SqliteOwnedPtr = WasmPtr & Brand<"SqliteOwned">;
+/**
+ * A NUL-terminated UTF-8 string in memory allocated with `sqlite3_malloc`,
+ * which the holder frees with `sqlite3_free`.
+ */
+export type SqliteOwnedCStringPtr = SqliteOwnedPtr & CStringPtr;
+/** An open database connection, `sqlite3*`. */
+export type SqliteDbPtr = WasmPtr & Brand<"SqliteDb">;
+/** A prepared statement, `sqlite3_stmt*`. */
+export type SqliteStmtPtr = WasmPtr & Brand<"SqliteStmt">;
+/**
+ * A dynamically typed SQL value, `sqlite3_value*`, such as a column value or an
+ * argument of an application-defined function.
+ */
+export type SqliteValuePtr = WasmPtr & Brand<"SqliteValue">;
+/**
+ * A protected value copied with `sqlite3_value_dup`, which the holder frees
+ * with `sqlite3_value_free`.
+ *
+ * Column values, function arguments and the other values SQLite passes are
+ * borrowed, so `sqlite3_value_free` rejects them.
+ */
+export type SqliteOwnedValuePtr = SqliteValuePtr & Brand<"SqliteOwnedValue">;
+/** The context of an application-defined function call, `sqlite3_context*`. */
+export type SqliteContextPtr = WasmPtr & Brand<"SqliteContext">;
+/** A VFS struct, `sqlite3_vfs*`. */
+export type SqliteVfsPtr = WasmPtr & Brand<"SqliteVfs">;
+/**
+ * A file SQLite opened through a VFS, `sqlite3_file*`.
+ *
+ * SQLite allocates it with the VFS's `szOsFile` bytes before calling `xOpen`.
+ */
+export type SqliteFilePtr = WasmPtr & Brand<"SqliteFile">;
+/**
+ * A database filename SQLite created, `sqlite3_filename`, as `xOpen` receives
+ * it.
+ *
+ * SQLite stores the URI parameters after the name, where the `sqlite3_uri_*`
+ * functions read them, so no other C string can take its place.
+ */
+export type SqliteFilenamePtr = CStringPtr & Brand<"SqliteFilename">;
+/**
+ * The query planner's exchange with a virtual table's `xBestIndex`,
+ * `sqlite3_index_info*`.
+ */
+export type SqliteIndexInfoPtr = WasmPtr & Brand<"SqliteIndexInfo">;
+/**
+ * A C function pointer, which in wasm is an index into the function table, not
+ * a memory address.
+ */
+export type SqliteFunctionPtr = number & Brand<"SqliteFunctionPtr">;
+/**
+ * The destructor argument of `sqlite3_bind_text`, `sqlite3_bind_blob`,
+ * `sqlite3_result_text` and `sqlite3_result_blob`.
+ *
+ * {@link SQLITE_STATIC} promises the memory outlives the value,
+ * {@link SQLITE_TRANSIENT} makes SQLite copy it, and a function pointer such as
+ * {@link SQLITE_WASM_DEALLOC} hands it to SQLite, which frees it even when the
+ * call fails.
+ */
+export type SqliteDestructor = typeof SQLITE_STATIC | typeof SQLITE_TRANSIENT | SqliteFunctionPtr;
+//# sourceMappingURL=Pointer.d.ts.map

package/dist/src/Pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pointer.d.ts","sourceRoot":"","sources":["../../src/Pointer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAEjB,MAAM,gBAAgB,CAAC;AAExB,mCAAmC;AACnC,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC;AAExB;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,UAAU,CAAC;AAEhE,+CAA+C;AAC/C,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;AAEtD,6CAA6C;AAC7C,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,KAAK,CAAC,kBAAkB,CAAC,CAAC;AAE7E,+EAA+E;AAC/E,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,KAAK,CAAC,eAAe,CAAC,CAAC;AAEhE,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;AAExD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,KAAK,CAAC,gBAAgB,CAAC,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAC;AAEpE;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,KAAK,CAAC,mBAAmB,CAAC,CAAC;AAEpE;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAC1B,OAAO,aAAa,GAAG,OAAO,gBAAgB,GAAG,iBAAiB,CAAC"}

package/dist/src/Pointer.js

@@ -0,0 +1,15 @@
+/**
+ * Branded pointers into SQLite's wasm memory and function table.
+ *
+ * At runtime every pointer is a wasm32 address, a plain number. The brands keep
+ * C types apart, so a statement cannot be passed where a connection is
+ * expected, borrowed memory cannot be freed, and no JavaScript string converts
+ * to a C string implicitly. Only this package creates pointer values, from what
+ * the wasm returns.
+ *
+ * The loader caps memory at 2 GiB (32768 pages), so every address is a
+ * non-negative i32 and reads with `getUint32` need no `>>> 0`.
+ *
+ * @module
+ */
+export {};