@powersync/web 1.6.0 → 1.8.0

package/dist/worker/WASQLiteDB.umd.js

@@ -0,0 +1,2780 @@
+var sdk_web;
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./lib/src/shared/open-db.js":
+/*!***********************************!*\
+  !*** ./lib/src/shared/open-db.js ***!
+  \***********************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   _openDB: () => (/* binding */ _openDB)
+/* harmony export */ });
+/* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
+/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
+/* harmony import */ var async_mutex__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! async-mutex */ "../../node_modules/async-mutex/index.mjs");
+
+
+
+
+let nextId = 1;
+async function _openDB(dbFileName, options = { useWebWorker: true }) {
+    const { default: moduleFactory } = await __webpack_require__.e(/*! import() */ "node_modules_journeyapps_wa-sqlite_dist_wa-sqlite-async_mjs").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs */ "../../node_modules/@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs"));
+    const module = await moduleFactory();
+    const sqlite3 = _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory(module);
+    const { IDBBatchAtomicVFS } = await __webpack_require__.e(/*! import() */ "node_modules_journeyapps_wa-sqlite_src_examples_IDBBatchAtomicVFS_js").then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js */ "../../node_modules/@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js"));
+    const vfs = new IDBBatchAtomicVFS(dbFileName);
+    sqlite3.vfs_register(vfs, true);
+    const db = await sqlite3.open_v2(dbFileName);
+    const statementMutex = new async_mutex__WEBPACK_IMPORTED_MODULE_1__.Mutex();
+    /**
+     * Listeners are exclusive to the DB connection.
+     */
+    const listeners = new Map();
+    let updatedTables = new Set();
+    let updateTimer = null;
+    function fireUpdates() {
+        updateTimer = null;
+        const event = { tables: [...updatedTables], groupedUpdates: {}, rawUpdates: [] };
+        updatedTables.clear();
+        Array.from(listeners.values()).forEach((l) => l(event));
+    }
+    sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
+        updatedTables.add(tableName);
+        if (updateTimer == null) {
+            updateTimer = setTimeout(fireUpdates, 0);
+        }
+    });
+    /**
+     * This executes single SQL statements inside a requested lock.
+     */
+    const execute = async (sql, bindings) => {
+        // Running multiple statements on the same connection concurrently should not be allowed
+        return _acquireExecuteLock(async () => {
+            return executeSingleStatement(sql, bindings);
+        });
+    };
+    /**
+     * This requests a lock for executing statements.
+     * Should only be used internally.
+     */
+    const _acquireExecuteLock = (callback) => {
+        return statementMutex.runExclusive(callback);
+    };
+    /**
+     * This executes a single statement using SQLite3.
+     */
+    const executeSingleStatement = async (sql, bindings) => {
+        const results = [];
+        for await (const stmt of sqlite3.statements(db, sql)) {
+            let columns;
+            const wrappedBindings = bindings ? [bindings] : [[]];
+            for (const binding of wrappedBindings) {
+                // TODO not sure why this is needed currently, but booleans break
+                binding.forEach((b, index, arr) => {
+                    if (typeof b == 'boolean') {
+                        arr[index] = b ? 1 : 0;
+                    }
+                });
+                sqlite3.reset(stmt);
+                if (bindings) {
+                    sqlite3.bind_collection(stmt, binding);
+                }
+                const rows = [];
+                while ((await sqlite3.step(stmt)) === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW) {
+                    const row = sqlite3.row(stmt);
+                    rows.push(row);
+                }
+                columns = columns ?? sqlite3.column_names(stmt);
+                if (columns.length) {
+                    results.push({ columns, rows });
+                }
+            }
+            // When binding parameters, only a single statement is executed.
+            if (bindings) {
+                break;
+            }
+        }
+        const rows = [];
+        for (const resultset of results) {
+            for (const row of resultset.rows) {
+                const outRow = {};
+                resultset.columns.forEach((key, index) => {
+                    outRow[key] = row[index];
+                });
+                rows.push(outRow);
+            }
+        }
+        const result = {
+            insertId: sqlite3.last_insert_id(db),
+            rowsAffected: sqlite3.changes(db),
+            rows: {
+                _array: rows,
+                length: rows.length
+            }
+        };
+        return result;
+    };
+    /**
+     * This executes SQL statements in a batch.
+     */
+    const executeBatch = async (sql, bindings) => {
+        return _acquireExecuteLock(async () => {
+            let affectedRows = 0;
+            const str = sqlite3.str_new(db, sql);
+            const query = sqlite3.str_value(str);
+            try {
+                await executeSingleStatement('BEGIN TRANSACTION');
+                //Prepare statement once
+                const prepared = await sqlite3.prepare_v2(db, query);
+                if (prepared === null) {
+                    return {
+                        rowsAffected: 0,
+                        rows: { _array: [], length: 0 }
+                    };
+                }
+                const wrappedBindings = bindings ? bindings : [];
+                for (const binding of wrappedBindings) {
+                    // TODO not sure why this is needed currently, but booleans break
+                    for (let i = 0; i < binding.length; i++) {
+                        const b = binding[i];
+                        if (typeof b == 'boolean') {
+                            binding[i] = b ? 1 : 0;
+                        }
+                    }
+                    //Reset bindings
+                    sqlite3.reset(prepared.stmt);
+                    if (bindings) {
+                        sqlite3.bind_collection(prepared.stmt, binding);
+                    }
+                    const result = await sqlite3.step(prepared.stmt);
+                    if (result === _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE) {
+                        //The value returned by sqlite3_changes() immediately after an INSERT, UPDATE or DELETE statement run on a view is always zero.
+                        affectedRows += sqlite3.changes(db);
+                    }
+                }
+                //Finalize prepared statement
+                await sqlite3.finalize(prepared.stmt);
+                await executeSingleStatement('COMMIT');
+            }
+            catch (err) {
+                await executeSingleStatement('ROLLBACK');
+                return {
+                    rowsAffected: 0,
+                    rows: { _array: [], length: 0 }
+                };
+            }
+            finally {
+                sqlite3.str_finish(str);
+            }
+            const result = {
+                rowsAffected: affectedRows,
+                rows: { _array: [], length: 0 }
+            };
+            return result;
+        });
+    };
+    if (options.useWebWorker) {
+        const registerOnTableChange = (callback) => {
+            const id = nextId++;
+            listeners.set(id, callback);
+            return comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(() => {
+                listeners.delete(id);
+            });
+        };
+        return {
+            execute: comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(execute),
+            executeBatch: comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(executeBatch),
+            registerOnTableChange: comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(registerOnTableChange),
+            close: comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(() => {
+                sqlite3.close(db);
+            })
+        };
+    }
+    const registerOnTableChange = (callback) => {
+        const id = nextId++;
+        listeners.set(id, callback);
+        return () => {
+            listeners.delete(id);
+        };
+    };
+    return {
+        execute: execute,
+        executeBatch: executeBatch,
+        registerOnTableChange: registerOnTableChange,
+        close: () => sqlite3.close(db)
+    };
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/async-mutex/index.mjs":
+/*!************************************************!*\
+  !*** ../../node_modules/async-mutex/index.mjs ***!
+  \************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   E_ALREADY_LOCKED: () => (/* binding */ E_ALREADY_LOCKED),
+/* harmony export */   E_CANCELED: () => (/* binding */ E_CANCELED),
+/* harmony export */   E_TIMEOUT: () => (/* binding */ E_TIMEOUT),
+/* harmony export */   Mutex: () => (/* binding */ Mutex),
+/* harmony export */   Semaphore: () => (/* binding */ Semaphore),
+/* harmony export */   tryAcquire: () => (/* binding */ tryAcquire),
+/* harmony export */   withTimeout: () => (/* binding */ withTimeout)
+/* harmony export */ });
+const E_TIMEOUT = new Error('timeout while waiting for mutex to become available');
+const E_ALREADY_LOCKED = new Error('mutex already locked');
+const E_CANCELED = new Error('request for lock canceled');
+
+var __awaiter$2 = ( false) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class Semaphore {
+    constructor(_value, _cancelError = E_CANCELED) {
+        this._value = _value;
+        this._cancelError = _cancelError;
+        this._weightedQueues = [];
+        this._weightedWaiters = [];
+    }
+    acquire(weight = 1) {
+        if (weight <= 0)
+            throw new Error(`invalid weight ${weight}: must be positive`);
+        return new Promise((resolve, reject) => {
+            if (!this._weightedQueues[weight - 1])
+                this._weightedQueues[weight - 1] = [];
+            this._weightedQueues[weight - 1].push({ resolve, reject });
+            this._dispatch();
+        });
+    }
+    runExclusive(callback, weight = 1) {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            const [value, release] = yield this.acquire(weight);
+            try {
+                return yield callback(value);
+            }
+            finally {
+                release();
+            }
+        });
+    }
+    waitForUnlock(weight = 1) {
+        if (weight <= 0)
+            throw new Error(`invalid weight ${weight}: must be positive`);
+        return new Promise((resolve) => {
+            if (!this._weightedWaiters[weight - 1])
+                this._weightedWaiters[weight - 1] = [];
+            this._weightedWaiters[weight - 1].push(resolve);
+            this._dispatch();
+        });
+    }
+    isLocked() {
+        return this._value <= 0;
+    }
+    getValue() {
+        return this._value;
+    }
+    setValue(value) {
+        this._value = value;
+        this._dispatch();
+    }
+    release(weight = 1) {
+        if (weight <= 0)
+            throw new Error(`invalid weight ${weight}: must be positive`);
+        this._value += weight;
+        this._dispatch();
+    }
+    cancel() {
+        this._weightedQueues.forEach((queue) => queue.forEach((entry) => entry.reject(this._cancelError)));
+        this._weightedQueues = [];
+    }
+    _dispatch() {
+        var _a;
+        for (let weight = this._value; weight > 0; weight--) {
+            const queueEntry = (_a = this._weightedQueues[weight - 1]) === null || _a === void 0 ? void 0 : _a.shift();
+            if (!queueEntry)
+                continue;
+            const previousValue = this._value;
+            const previousWeight = weight;
+            this._value -= weight;
+            weight = this._value + 1;
+            queueEntry.resolve([previousValue, this._newReleaser(previousWeight)]);
+        }
+        this._drainUnlockWaiters();
+    }
+    _newReleaser(weight) {
+        let called = false;
+        return () => {
+            if (called)
+                return;
+            called = true;
+            this.release(weight);
+        };
+    }
+    _drainUnlockWaiters() {
+        for (let weight = this._value; weight > 0; weight--) {
+            if (!this._weightedWaiters[weight - 1])
+                continue;
+            this._weightedWaiters[weight - 1].forEach((waiter) => waiter());
+            this._weightedWaiters[weight - 1] = [];
+        }
+    }
+}
+
+var __awaiter$1 = ( false) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+class Mutex {
+    constructor(cancelError) {
+        this._semaphore = new Semaphore(1, cancelError);
+    }
+    acquire() {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            const [, releaser] = yield this._semaphore.acquire();
+            return releaser;
+        });
+    }
+    runExclusive(callback) {
+        return this._semaphore.runExclusive(() => callback());
+    }
+    isLocked() {
+        return this._semaphore.isLocked();
+    }
+    waitForUnlock() {
+        return this._semaphore.waitForUnlock();
+    }
+    release() {
+        if (this._semaphore.isLocked())
+            this._semaphore.release();
+    }
+    cancel() {
+        return this._semaphore.cancel();
+    }
+}
+
+var __awaiter = ( false) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+function withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {
+    return {
+        acquire: (weight) => {
+            if (weight !== undefined && weight <= 0) {
+                throw new Error(`invalid weight ${weight}: must be positive`);
+            }
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let isTimeout = false;
+                const handle = setTimeout(() => {
+                    isTimeout = true;
+                    reject(timeoutError);
+                }, timeout);
+                try {
+                    const ticket = yield sync.acquire(weight);
+                    if (isTimeout) {
+                        const release = Array.isArray(ticket) ? ticket[1] : ticket;
+                        release();
+                    }
+                    else {
+                        clearTimeout(handle);
+                        resolve(ticket);
+                    }
+                }
+                catch (e) {
+                    if (!isTimeout) {
+                        clearTimeout(handle);
+                        reject(e);
+                    }
+                }
+            }));
+        },
+        runExclusive(callback, weight) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let release = () => undefined;
+                try {
+                    const ticket = yield this.acquire(weight);
+                    if (Array.isArray(ticket)) {
+                        release = ticket[1];
+                        return yield callback(ticket[0]);
+                    }
+                    else {
+                        release = ticket;
+                        return yield callback();
+                    }
+                }
+                finally {
+                    release();
+                }
+            });
+        },
+        release(weight) {
+            sync.release(weight);
+        },
+        cancel() {
+            return sync.cancel();
+        },
+        waitForUnlock: (weight) => {
+            if (weight !== undefined && weight <= 0) {
+                throw new Error(`invalid weight ${weight}: must be positive`);
+            }
+            return new Promise((resolve, reject) => {
+                const handle = setTimeout(() => reject(timeoutError), timeout);
+                sync.waitForUnlock(weight).then(() => {
+                    clearTimeout(handle);
+                    resolve();
+                });
+            });
+        },
+        isLocked: () => sync.isLocked(),
+        getValue: () => sync.getValue(),
+        setValue: (value) => sync.setValue(value),
+    };
+}
+
+// eslint-disable-next-lisne @typescript-eslint/explicit-module-boundary-types
+function tryAcquire(sync, alreadyAcquiredError = E_ALREADY_LOCKED) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return withTimeout(sync, 0, alreadyAcquiredError);
+}
+
+
+
+
+/***/ }),
+
+/***/ "../../node_modules/comlink/dist/esm/comlink.mjs":
+/*!*******************************************************!*\
+  !*** ../../node_modules/comlink/dist/esm/comlink.mjs ***!
+  \*******************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   createEndpoint: () => (/* binding */ createEndpoint),
+/* harmony export */   expose: () => (/* binding */ expose),
+/* harmony export */   finalizer: () => (/* binding */ finalizer),
+/* harmony export */   proxy: () => (/* binding */ proxy),
+/* harmony export */   proxyMarker: () => (/* binding */ proxyMarker),
+/* harmony export */   releaseProxy: () => (/* binding */ releaseProxy),
+/* harmony export */   transfer: () => (/* binding */ transfer),
+/* harmony export */   transferHandlers: () => (/* binding */ transferHandlers),
+/* harmony export */   windowEndpoint: () => (/* binding */ windowEndpoint),
+/* harmony export */   wrap: () => (/* binding */ wrap)
+/* harmony export */ });
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const proxyMarker = Symbol("Comlink.proxy");
+const createEndpoint = Symbol("Comlink.endpoint");
+const releaseProxy = Symbol("Comlink.releaseProxy");
+const finalizer = Symbol("Comlink.finalizer");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+/**
+ * Internal transfer handle to handle objects marked to proxy.
+ */
+const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+        const { port1, port2 } = new MessageChannel();
+        expose(obj, port1);
+        return [port2, [port2]];
+    },
+    deserialize(port) {
+        port.start();
+        return wrap(port);
+    },
+};
+/**
+ * Internal transfer handler to handle thrown exceptions.
+ */
+const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+        let serialized;
+        if (value instanceof Error) {
+            serialized = {
+                isError: true,
+                value: {
+                    message: value.message,
+                    name: value.name,
+                    stack: value.stack,
+                },
+            };
+        }
+        else {
+            serialized = { isError: false, value };
+        }
+        return [serialized, []];
+    },
+    deserialize(serialized) {
+        if (serialized.isError) {
+            throw Object.assign(new Error(serialized.value.message), serialized.value);
+        }
+        throw serialized.value;
+    },
+};
+/**
+ * Allows customizing the serialization of certain values.
+ */
+const transferHandlers = new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler],
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+    for (const allowedOrigin of allowedOrigins) {
+        if (origin === allowedOrigin || allowedOrigin === "*") {
+            return true;
+        }
+        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+            return true;
+        }
+    }
+    return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+    ep.addEventListener("message", function callback(ev) {
+        if (!ev || !ev.data) {
+            return;
+        }
+        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+            return;
+        }
+        const { id, type, path } = Object.assign({ path: [] }, ev.data);
+        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+        let returnValue;
+        try {
+            const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+            const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+            switch (type) {
+                case "GET" /* MessageType.GET */:
+                    {
+                        returnValue = rawValue;
+                    }
+                    break;
+                case "SET" /* MessageType.SET */:
+                    {
+                        parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+                        returnValue = true;
+                    }
+                    break;
+                case "APPLY" /* MessageType.APPLY */:
+                    {
+                        returnValue = rawValue.apply(parent, argumentList);
+                    }
+                    break;
+                case "CONSTRUCT" /* MessageType.CONSTRUCT */:
+                    {
+                        const value = new rawValue(...argumentList);
+                        returnValue = proxy(value);
+                    }
+                    break;
+                case "ENDPOINT" /* MessageType.ENDPOINT */:
+                    {
+                        const { port1, port2 } = new MessageChannel();
+                        expose(obj, port2);
+                        returnValue = transfer(port1, [port1]);
+                    }
+                    break;
+                case "RELEASE" /* MessageType.RELEASE */:
+                    {
+                        returnValue = undefined;
+                    }
+                    break;
+                default:
+                    return;
+            }
+        }
+        catch (value) {
+            returnValue = { value, [throwMarker]: 0 };
+        }
+        Promise.resolve(returnValue)
+            .catch((value) => {
+            return { value, [throwMarker]: 0 };
+        })
+            .then((returnValue) => {
+            const [wireValue, transferables] = toWireValue(returnValue);
+            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+            if (type === "RELEASE" /* MessageType.RELEASE */) {
+                // detach and deactive after sending release response above.
+                ep.removeEventListener("message", callback);
+                closeEndPoint(ep);
+                if (finalizer in obj && typeof obj[finalizer] === "function") {
+                    obj[finalizer]();
+                }
+            }
+        })
+            .catch((error) => {
+            // Send Serialization Error To Caller
+            const [wireValue, transferables] = toWireValue({
+                value: new TypeError("Unserializable return value"),
+                [throwMarker]: 0,
+            });
+            ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+        });
+    });
+    if (ep.start) {
+        ep.start();
+    }
+}
+function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+        endpoint.close();
+}
+function wrap(ep, target) {
+    return createProxy(ep, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+        throw new Error("Proxy has been released and is not useable");
+    }
+}
+function releaseEndpoint(ep) {
+    return requestResponseMessage(ep, {
+        type: "RELEASE" /* MessageType.RELEASE */,
+    }).then(() => {
+        closeEndPoint(ep);
+    });
+}
+const proxyCounter = new WeakMap();
+const proxyFinalizers = "FinalizationRegistry" in globalThis &&
+    new FinalizationRegistry((ep) => {
+        const newCount = (proxyCounter.get(ep) || 0) - 1;
+        proxyCounter.set(ep, newCount);
+        if (newCount === 0) {
+            releaseEndpoint(ep);
+        }
+    });
+function registerProxy(proxy, ep) {
+    const newCount = (proxyCounter.get(ep) || 0) + 1;
+    proxyCounter.set(ep, newCount);
+    if (proxyFinalizers) {
+        proxyFinalizers.register(proxy, ep, proxy);
+    }
+}
+function unregisterProxy(proxy) {
+    if (proxyFinalizers) {
+        proxyFinalizers.unregister(proxy);
+    }
+}
+function createProxy(ep, path = [], target = function () { }) {
+    let isProxyReleased = false;
+    const proxy = new Proxy(target, {
+        get(_target, prop) {
+            throwIfProxyReleased(isProxyReleased);
+            if (prop === releaseProxy) {
+                return () => {
+                    unregisterProxy(proxy);
+                    releaseEndpoint(ep);
+                    isProxyReleased = true;
+                };
+            }
+            if (prop === "then") {
+                if (path.length === 0) {
+                    return { then: () => proxy };
+                }
+                const r = requestResponseMessage(ep, {
+                    type: "GET" /* MessageType.GET */,
+                    path: path.map((p) => p.toString()),
+                }).then(fromWireValue);
+                return r.then.bind(r);
+            }
+            return createProxy(ep, [...path, prop]);
+        },
+        set(_target, prop, rawValue) {
+            throwIfProxyReleased(isProxyReleased);
+            // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
+            // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
+            const [value, transferables] = toWireValue(rawValue);
+            return requestResponseMessage(ep, {
+                type: "SET" /* MessageType.SET */,
+                path: [...path, prop].map((p) => p.toString()),
+                value,
+            }, transferables).then(fromWireValue);
+        },
+        apply(_target, _thisArg, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const last = path[path.length - 1];
+            if (last === createEndpoint) {
+                return requestResponseMessage(ep, {
+                    type: "ENDPOINT" /* MessageType.ENDPOINT */,
+                }).then(fromWireValue);
+            }
+            // We just pretend that `bind()` didn’t happen.
+            if (last === "bind") {
+                return createProxy(ep, path.slice(0, -1));
+            }
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, {
+                type: "APPLY" /* MessageType.APPLY */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+        construct(_target, rawArgumentList) {
+            throwIfProxyReleased(isProxyReleased);
+            const [argumentList, transferables] = processArguments(rawArgumentList);
+            return requestResponseMessage(ep, {
+                type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
+                path: path.map((p) => p.toString()),
+                argumentList,
+            }, transferables).then(fromWireValue);
+        },
+    });
+    registerProxy(proxy, ep);
+    return proxy;
+}
+function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+const transferCache = new WeakMap();
+function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+}
+function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+}
+function windowEndpoint(w, context = globalThis, targetOrigin = "*") {
+    return {
+        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),
+        addEventListener: context.addEventListener.bind(context),
+        removeEventListener: context.removeEventListener.bind(context),
+    };
+}
+function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+        if (handler.canHandle(value)) {
+            const [serializedValue, transferables] = handler.serialize(value);
+            return [
+                {
+                    type: "HANDLER" /* WireValueType.HANDLER */,
+                    name,
+                    value: serializedValue,
+                },
+                transferables,
+            ];
+        }
+    }
+    return [
+        {
+            type: "RAW" /* WireValueType.RAW */,
+            value,
+        },
+        transferCache.get(value) || [],
+    ];
+}
+function fromWireValue(value) {
+    switch (value.type) {
+        case "HANDLER" /* WireValueType.HANDLER */:
+            return transferHandlers.get(value.name).deserialize(value.value);
+        case "RAW" /* WireValueType.RAW */:
+            return value.value;
+    }
+}
+function requestResponseMessage(ep, msg, transfers) {
+    return new Promise((resolve) => {
+        const id = generateUUID();
+        ep.addEventListener("message", function l(ev) {
+            if (!ev.data || !ev.data.id || ev.data.id !== id) {
+                return;
+            }
+            ep.removeEventListener("message", l);
+            resolve(ev.data);
+        });
+        if (ep.start) {
+            ep.start();
+        }
+        ep.postMessage(Object.assign({ id }, msg), transfers);
+    });
+}
+function generateUUID() {
+    return new Array(4)
+        .fill(0)
+        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+        .join("-");
+}
+
+
+//# sourceMappingURL=comlink.mjs.map
+
+
+/***/ }),
+
+/***/ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js":
+/*!*******************************************************************!*\
+  !*** ../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js ***!
+  \*******************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Factory: () => (/* binding */ Factory),
+/* harmony export */   SQLITE_ABORT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ABORT),
+/* harmony export */   SQLITE_ACCESS_EXISTS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_EXISTS),
+/* harmony export */   SQLITE_ACCESS_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_READ),
+/* harmony export */   SQLITE_ACCESS_READWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ACCESS_READWRITE),
+/* harmony export */   SQLITE_ALTER_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ALTER_TABLE),
+/* harmony export */   SQLITE_ANALYZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ANALYZE),
+/* harmony export */   SQLITE_ATTACH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ATTACH),
+/* harmony export */   SQLITE_AUTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_AUTH),
+/* harmony export */   SQLITE_BLOB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BLOB),
+/* harmony export */   SQLITE_BUSY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BUSY),
+/* harmony export */   SQLITE_CANTOPEN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CANTOPEN),
+/* harmony export */   SQLITE_CONSTRAINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT),
+/* harmony export */   SQLITE_CONSTRAINT_CHECK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_CHECK),
+/* harmony export */   SQLITE_CONSTRAINT_COMMITHOOK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_COMMITHOOK),
+/* harmony export */   SQLITE_CONSTRAINT_FOREIGNKEY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_FOREIGNKEY),
+/* harmony export */   SQLITE_CONSTRAINT_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_CONSTRAINT_NOTNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_NOTNULL),
+/* harmony export */   SQLITE_CONSTRAINT_PINNED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_PINNED),
+/* harmony export */   SQLITE_CONSTRAINT_PRIMARYKEY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_PRIMARYKEY),
+/* harmony export */   SQLITE_CONSTRAINT_ROWID: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_ROWID),
+/* harmony export */   SQLITE_CONSTRAINT_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_TRIGGER),
+/* harmony export */   SQLITE_CONSTRAINT_UNIQUE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_UNIQUE),
+/* harmony export */   SQLITE_CONSTRAINT_VTAB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CONSTRAINT_VTAB),
+/* harmony export */   SQLITE_COPY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_COPY),
+/* harmony export */   SQLITE_CORRUPT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CORRUPT),
+/* harmony export */   SQLITE_CREATE_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_INDEX),
+/* harmony export */   SQLITE_CREATE_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_INDEX),
+/* harmony export */   SQLITE_CREATE_TEMP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_TRIGGER),
+/* harmony export */   SQLITE_CREATE_TEMP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TEMP_VIEW),
+/* harmony export */   SQLITE_CREATE_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_TRIGGER),
+/* harmony export */   SQLITE_CREATE_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_VIEW),
+/* harmony export */   SQLITE_CREATE_VTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_CREATE_VTABLE),
+/* harmony export */   SQLITE_DELETE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DELETE),
+/* harmony export */   SQLITE_DENY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DENY),
+/* harmony export */   SQLITE_DETACH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DETACH),
+/* harmony export */   SQLITE_DETERMINISTIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DETERMINISTIC),
+/* harmony export */   SQLITE_DIRECTONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DIRECTONLY),
+/* harmony export */   SQLITE_DONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE),
+/* harmony export */   SQLITE_DROP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_INDEX),
+/* harmony export */   SQLITE_DROP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_INDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_INDEX),
+/* harmony export */   SQLITE_DROP_TEMP_TABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_TRIGGER),
+/* harmony export */   SQLITE_DROP_TEMP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TEMP_VIEW),
+/* harmony export */   SQLITE_DROP_TRIGGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_TRIGGER),
+/* harmony export */   SQLITE_DROP_VIEW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_VIEW),
+/* harmony export */   SQLITE_DROP_VTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DROP_VTABLE),
+/* harmony export */   SQLITE_EMPTY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_EMPTY),
+/* harmony export */   SQLITE_ERROR: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ERROR),
+/* harmony export */   SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_BEGIN_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_BUSYHANDLER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_BUSYHANDLER),
+/* harmony export */   SQLITE_FCNTL_CHUNK_SIZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CHUNK_SIZE),
+/* harmony export */   SQLITE_FCNTL_CKPT_DONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CKPT_DONE),
+/* harmony export */   SQLITE_FCNTL_CKPT_START: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_CKPT_START),
+/* harmony export */   SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_COMMIT_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_COMMIT_PHASETWO: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_COMMIT_PHASETWO),
+/* harmony export */   SQLITE_FCNTL_DATA_VERSION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_DATA_VERSION),
+/* harmony export */   SQLITE_FCNTL_FILE_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_FILE_POINTER),
+/* harmony export */   SQLITE_FCNTL_GET_LOCKPROXYFILE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_GET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_HAS_MOVED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_HAS_MOVED),
+/* harmony export */   SQLITE_FCNTL_JOURNAL_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_JOURNAL_POINTER),
+/* harmony export */   SQLITE_FCNTL_LAST_ERRNO: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LAST_ERRNO),
+/* harmony export */   SQLITE_FCNTL_LOCKSTATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LOCKSTATE),
+/* harmony export */   SQLITE_FCNTL_LOCK_TIMEOUT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_LOCK_TIMEOUT),
+/* harmony export */   SQLITE_FCNTL_MMAP_SIZE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_MMAP_SIZE),
+/* harmony export */   SQLITE_FCNTL_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PDB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PDB),
+/* harmony export */   SQLITE_FCNTL_PERSIST_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PERSIST_WAL),
+/* harmony export */   SQLITE_FCNTL_POWERSAFE_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_PRAGMA),
+/* harmony export */   SQLITE_FCNTL_RBU: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_RBU),
+/* harmony export */   SQLITE_FCNTL_RESERVE_BYTES: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_RESERVE_BYTES),
+/* harmony export */   SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_SET_LOCKPROXYFILE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_SIZE_HINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SIZE_HINT),
+/* harmony export */   SQLITE_FCNTL_SIZE_LIMIT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SIZE_LIMIT),
+/* harmony export */   SQLITE_FCNTL_SYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SYNC),
+/* harmony export */   SQLITE_FCNTL_SYNC_OMITTED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_SYNC_OMITTED),
+/* harmony export */   SQLITE_FCNTL_TEMPFILENAME: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_TEMPFILENAME),
+/* harmony export */   SQLITE_FCNTL_TRACE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_TRACE),
+/* harmony export */   SQLITE_FCNTL_VFSNAME: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_VFSNAME),
+/* harmony export */   SQLITE_FCNTL_VFS_POINTER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_VFS_POINTER),
+/* harmony export */   SQLITE_FCNTL_WAL_BLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WAL_BLOCK),
+/* harmony export */   SQLITE_FCNTL_WIN32_AV_RETRY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_AV_RETRY),
+/* harmony export */   SQLITE_FCNTL_WIN32_GET_HANDLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_GET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_WIN32_SET_HANDLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_WIN32_SET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_ZIPVFS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FCNTL_ZIPVFS),
+/* harmony export */   SQLITE_FLOAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FLOAT),
+/* harmony export */   SQLITE_FORMAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FORMAT),
+/* harmony export */   SQLITE_FULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FULL),
+/* harmony export */   SQLITE_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FUNCTION),
+/* harmony export */   SQLITE_IGNORE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IGNORE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_EQ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_EQ),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_FUNCTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GLOB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GLOB),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_GT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_IS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_IS),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNOT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOTNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNOTNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_ISNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LIKE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LIKE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_LT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_MATCH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_MATCH),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_NE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_NE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_REGEXP: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_CONSTRAINT_REGEXP),
+/* harmony export */   SQLITE_INDEX_SCAN_UNIQUE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INDEX_SCAN_UNIQUE),
+/* harmony export */   SQLITE_INNOCUOUS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INNOCUOUS),
+/* harmony export */   SQLITE_INSERT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INSERT),
+/* harmony export */   SQLITE_INTEGER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTEGER),
+/* harmony export */   SQLITE_INTERNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTERNAL),
+/* harmony export */   SQLITE_INTERRUPT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTERRUPT),
+/* harmony export */   SQLITE_IOCAP_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_ATOMIC16K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC16K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC1K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC1K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC2K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC2K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC32K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC32K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC4K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC4K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC512: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC512),
+/* harmony export */   SQLITE_IOCAP_ATOMIC64K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC64K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC8K: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_ATOMIC8K),
+/* harmony export */   SQLITE_IOCAP_BATCH_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_BATCH_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_IMMUTABLE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_IMMUTABLE),
+/* harmony export */   SQLITE_IOCAP_POWERSAFE_OVERWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_IOCAP_SAFE_APPEND: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SAFE_APPEND),
+/* harmony export */   SQLITE_IOCAP_SEQUENTIAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_SEQUENTIAL),
+/* harmony export */   SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN),
+/* harmony export */   SQLITE_IOERR: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR),
+/* harmony export */   SQLITE_IOERR_ACCESS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_ACCESS),
+/* harmony export */   SQLITE_IOERR_BEGIN_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_BEGIN_ATOMIC),
+/* harmony export */   SQLITE_IOERR_CHECKRESERVEDLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CHECKRESERVEDLOCK),
+/* harmony export */   SQLITE_IOERR_CLOSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_CLOSE),
+/* harmony export */   SQLITE_IOERR_COMMIT_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_COMMIT_ATOMIC),
+/* harmony export */   SQLITE_IOERR_DATA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DATA),
+/* harmony export */   SQLITE_IOERR_DELETE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DELETE),
+/* harmony export */   SQLITE_IOERR_DELETE_NOENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DELETE_NOENT),
+/* harmony export */   SQLITE_IOERR_DIR_FSYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_DIR_FSYNC),
+/* harmony export */   SQLITE_IOERR_FSTAT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_FSTAT),
+/* harmony export */   SQLITE_IOERR_FSYNC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_FSYNC),
+/* harmony export */   SQLITE_IOERR_GETTEMPPATH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_GETTEMPPATH),
+/* harmony export */   SQLITE_IOERR_LOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_LOCK),
+/* harmony export */   SQLITE_IOERR_NOMEM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_NOMEM),
+/* harmony export */   SQLITE_IOERR_RDLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_RDLOCK),
+/* harmony export */   SQLITE_IOERR_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_READ),
+/* harmony export */   SQLITE_IOERR_ROLLBACK_ATOMIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_ROLLBACK_ATOMIC),
+/* harmony export */   SQLITE_IOERR_SEEK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SEEK),
+/* harmony export */   SQLITE_IOERR_SHORT_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_SHORT_READ),
+/* harmony export */   SQLITE_IOERR_TRUNCATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_TRUNCATE),
+/* harmony export */   SQLITE_IOERR_UNLOCK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_UNLOCK),
+/* harmony export */   SQLITE_IOERR_VNODE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_VNODE),
+/* harmony export */   SQLITE_IOERR_WRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_IOERR_WRITE),
+/* harmony export */   SQLITE_LIMIT_ATTACHED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_ATTACHED),
+/* harmony export */   SQLITE_LIMIT_COLUMN: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_COLUMN),
+/* harmony export */   SQLITE_LIMIT_COMPOUND_SELECT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_COMPOUND_SELECT),
+/* harmony export */   SQLITE_LIMIT_EXPR_DEPTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_EXPR_DEPTH),
+/* harmony export */   SQLITE_LIMIT_FUNCTION_ARG: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_FUNCTION_ARG),
+/* harmony export */   SQLITE_LIMIT_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_LENGTH),
+/* harmony export */   SQLITE_LIMIT_LIKE_PATTERN_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_LIKE_PATTERN_LENGTH),
+/* harmony export */   SQLITE_LIMIT_SQL_LENGTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_SQL_LENGTH),
+/* harmony export */   SQLITE_LIMIT_TRIGGER_DEPTH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_TRIGGER_DEPTH),
+/* harmony export */   SQLITE_LIMIT_VARIABLE_NUMBER: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_VARIABLE_NUMBER),
+/* harmony export */   SQLITE_LIMIT_VDBE_OP: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_VDBE_OP),
+/* harmony export */   SQLITE_LIMIT_WORKER_THREADS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LIMIT_WORKER_THREADS),
+/* harmony export */   SQLITE_LOCKED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCKED),
+/* harmony export */   SQLITE_LOCK_EXCLUSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_EXCLUSIVE),
+/* harmony export */   SQLITE_LOCK_NONE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_NONE),
+/* harmony export */   SQLITE_LOCK_PENDING: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_PENDING),
+/* harmony export */   SQLITE_LOCK_RESERVED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_RESERVED),
+/* harmony export */   SQLITE_LOCK_SHARED: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_LOCK_SHARED),
+/* harmony export */   SQLITE_MISMATCH: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISMATCH),
+/* harmony export */   SQLITE_MISUSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE),
+/* harmony export */   SQLITE_NOLFS: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOLFS),
+/* harmony export */   SQLITE_NOMEM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOMEM),
+/* harmony export */   SQLITE_NOTADB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTADB),
+/* harmony export */   SQLITE_NOTFOUND: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTFOUND),
+/* harmony export */   SQLITE_NOTICE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTICE),
+/* harmony export */   SQLITE_NULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NULL),
+/* harmony export */   SQLITE_OK: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK),
+/* harmony export */   SQLITE_OPEN_AUTOPROXY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_AUTOPROXY),
+/* harmony export */   SQLITE_OPEN_CREATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_CREATE),
+/* harmony export */   SQLITE_OPEN_DELETEONCLOSE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_DELETEONCLOSE),
+/* harmony export */   SQLITE_OPEN_EXCLUSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_EXCLUSIVE),
+/* harmony export */   SQLITE_OPEN_FULLMUTEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_FULLMUTEX),
+/* harmony export */   SQLITE_OPEN_MAIN_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_DB),
+/* harmony export */   SQLITE_OPEN_MAIN_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MAIN_JOURNAL),
+/* harmony export */   SQLITE_OPEN_MEMORY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_MEMORY),
+/* harmony export */   SQLITE_OPEN_NOFOLLOW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_NOFOLLOW),
+/* harmony export */   SQLITE_OPEN_NOMUTEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_NOMUTEX),
+/* harmony export */   SQLITE_OPEN_PRIVATECACHE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_PRIVATECACHE),
+/* harmony export */   SQLITE_OPEN_READONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READONLY),
+/* harmony export */   SQLITE_OPEN_READWRITE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READWRITE),
+/* harmony export */   SQLITE_OPEN_SHAREDCACHE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SHAREDCACHE),
+/* harmony export */   SQLITE_OPEN_SUBJOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUBJOURNAL),
+/* harmony export */   SQLITE_OPEN_SUPER_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_SUPER_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TEMP_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_DB),
+/* harmony export */   SQLITE_OPEN_TEMP_JOURNAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TEMP_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TRANSIENT_DB: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_TRANSIENT_DB),
+/* harmony export */   SQLITE_OPEN_URI: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_URI),
+/* harmony export */   SQLITE_OPEN_WAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_WAL),
+/* harmony export */   SQLITE_PERM: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PERM),
+/* harmony export */   SQLITE_PRAGMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PRAGMA),
+/* harmony export */   SQLITE_PROTOCOL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_PROTOCOL),
+/* harmony export */   SQLITE_RANGE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE),
+/* harmony export */   SQLITE_READ: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READ),
+/* harmony export */   SQLITE_READONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_READONLY),
+/* harmony export */   SQLITE_RECURSIVE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RECURSIVE),
+/* harmony export */   SQLITE_REINDEX: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_REINDEX),
+/* harmony export */   SQLITE_ROW: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW),
+/* harmony export */   SQLITE_SAVEPOINT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SAVEPOINT),
+/* harmony export */   SQLITE_SCHEMA: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SCHEMA),
+/* harmony export */   SQLITE_SELECT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SELECT),
+/* harmony export */   SQLITE_STATIC: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_STATIC),
+/* harmony export */   SQLITE_SUBTYPE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SUBTYPE),
+/* harmony export */   SQLITE_SYNC_DATAONLY: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_DATAONLY),
+/* harmony export */   SQLITE_SYNC_FULL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_FULL),
+/* harmony export */   SQLITE_SYNC_NORMAL: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_SYNC_NORMAL),
+/* harmony export */   SQLITE_TEXT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TEXT),
+/* harmony export */   SQLITE_TOOBIG: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TOOBIG),
+/* harmony export */   SQLITE_TRANSACTION: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TRANSACTION),
+/* harmony export */   SQLITE_TRANSIENT: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TRANSIENT),
+/* harmony export */   SQLITE_UPDATE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UPDATE),
+/* harmony export */   SQLITE_UTF16: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16),
+/* harmony export */   SQLITE_UTF16BE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16BE),
+/* harmony export */   SQLITE_UTF16LE: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF16LE),
+/* harmony export */   SQLITE_UTF8: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_UTF8),
+/* harmony export */   SQLITE_WARNING: () => (/* reexport safe */ _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_WARNING),
+/* harmony export */   SQLiteError: () => (/* binding */ SQLiteError)
+/* harmony export */ });
+/* harmony import */ var _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sqlite-constants.js */ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-constants.js");
+// Copyright 2021 Roy T. Hashimoto. All Rights Reserved.
+
+
+
+
+/**
+ * Need to have a serializer for bigint
+ * https://github.com/GoogleChromeLabs/jsbi/issues/30
+ */
+if (typeof BigInt.prototype['toJSON'] == 'undefined') {
+  BigInt.prototype['toJSON'] = function() {
+    return this.toString();
+  };
+}
+
+const MAX_INT64 = 0x7fffffffffffffffn;
+const MIN_INT64 = -0x8000000000000000n;
+
+class SQLiteError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+}
+
+const async = true;
+
+const onTableChangeCallbacks = {};
+globalThis.__onTablesChanged = function(db, opType, tableName, rowId) {
+  setTimeout(() => onTableChangeCallbacks[db]?.(opType, tableName, rowId), 0);
+};
+
+/**
+ * Builds a Javascript API from the Emscripten module. This API is still
+ * low-level and closely corresponds to the C API exported by the module,
+ * but differs in some specifics like throwing exceptions on errors.
+ * @param {*} Module SQLite Emscripten module
+ * @returns {SQLiteAPI}
+ */
+function Factory(Module) {
+  /** @type {SQLiteAPI} */ const sqlite3 = {};
+
+  const sqliteFreeAddress = Module._getSqliteFree();
+
+  // Allocate some space for 32-bit returned values.
+  const tmp = Module._malloc(8);
+  const tmpPtr = [tmp, tmp + 4];
+
+  // Convert a JS string to a C string. sqlite3_malloc is used to allocate
+  // memory (use sqlite3_free to deallocate).
+  function createUTF8(s) {
+    if (typeof s !== 'string') return 0;
+    const n = Module.lengthBytesUTF8(s);
+    const zts = Module._sqlite3_malloc(n + 1);
+    Module.stringToUTF8(s, zts, n + 1);
+    return zts;
+  }
+
+  /**
+   * Concatenate 32-bit numbers into a 64-bit (signed) BigInt.
+   * @param {number} lo32
+   * @param {number} hi32
+   * @returns {bigint}
+   */
+  function cvt32x2ToBigInt(lo32, hi32) {
+    return (BigInt(hi32) << 32n) | (BigInt(lo32) & 0xffffffffn);
+  }
+
+  // /**
+  //  * Setup table change update callback
+  //  */
+  // var onTableChangedFunctionPointer = Module.addFunction(onTableUpdate);
+  // var passFnPointer = Module.cwrap('passFnPointer', 'undefined', ['number']);
+  // passFnPointer(onTableChangedFunctionPointer);
+  /**
+   * Concatenate 32-bit numbers and return as number or BigInt, depending
+   * on the value.
+   * @param {number} lo32
+   * @param {number} hi32
+   * @returns {number|bigint}
+   */
+  const cvt32x2AsSafe = (function() {
+    const hiMax = BigInt(Number.MAX_SAFE_INTEGER) >> 32n;
+    const hiMin = BigInt(Number.MIN_SAFE_INTEGER) >> 32n;
+
+    return function(lo32, hi32) {
+      if (hi32 > hiMax || hi32 < hiMin) {
+        // Can't be expressed as a Number so use BigInt.
+        return cvt32x2ToBigInt(lo32, hi32);
+      } else {
+        // Combine the upper and lower 32-bit numbers. The complication is
+        // that lo32 is a signed integer which makes manipulating its bits
+        // a little tricky - the sign bit gets handled separately.
+        return hi32 * 0x100000000 + (lo32 & 0x7fffffff) - (lo32 & 0x80000000);
+      }
+    };
+  })();
+
+  const databases = new Set();
+  function verifyDatabase(db) {
+    if (!databases.has(db)) {
+      throw new SQLiteError('not a database', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+    }
+  }
+
+  const mapStmtToDB = new Map();
+  function verifyStatement(stmt) {
+    if (!mapStmtToDB.has(stmt)) {
+      throw new SQLiteError('not a statement', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+    }
+  }
+
+  sqlite3.bind_collection = function(stmt, bindings) {
+    verifyStatement(stmt);
+    const isArray = Array.isArray(bindings);
+    const nBindings = sqlite3.bind_parameter_count(stmt);
+    for (let i = 1; i <= nBindings; ++i) {
+      const key = isArray ? i - 1 : sqlite3.bind_parameter_name(stmt, i);
+      const value = bindings[key];
+      if (value !== undefined) {
+        sqlite3.bind(stmt, i, value);
+      }
+    }
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  };
+
+  sqlite3.bind = function(stmt, i, value) {
+    verifyStatement(stmt);
+    switch (typeof value) {
+      case 'number':
+        if (value === (value | 0)) {
+          return sqlite3.bind_int(stmt, i, value);
+        } else {
+          return sqlite3.bind_double(stmt, i, value);
+        }
+      case 'string':
+        return sqlite3.bind_text(stmt, i, value);
+      default:
+        if (value instanceof Uint8Array || Array.isArray(value)) {
+          return sqlite3.bind_blob(stmt, i, value);
+        } else if (value === null) {
+          return sqlite3.bind_null(stmt, i);
+        } else if (typeof value === 'bigint') {
+          return sqlite3.bind_int64(stmt, i, value);
+        } else if (value === undefined) {
+          // Existing binding (or NULL) will be used.
+          return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NOTICE;
+        } else {
+          console.warn('unknown binding converted to null', value);
+          return sqlite3.bind_null(stmt, i);
+        }
+    }
+  };
+
+  sqlite3.bind_blob = (function() {
+    const fname = 'sqlite3_bind_blob';
+    const f = Module.cwrap(fname, ...decl('nnnnn:n'));
+    return function(stmt, i, value) {
+      verifyStatement(stmt);
+      // @ts-ignore
+      const byteLength = value.byteLength ?? value.length;
+      const ptr = Module._sqlite3_malloc(byteLength);
+      Module.HEAPU8.subarray(ptr).set(value);
+      const result = f(stmt, i, ptr, byteLength, sqliteFreeAddress);
+      // trace(fname, result);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.bind_parameter_count = (function() {
+    const fname = 'sqlite3_bind_parameter_count';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(stmt) {
+      verifyStatement(stmt);
+      const result = f(stmt);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.bind_double = (function() {
+    const fname = 'sqlite3_bind_double';
+    const f = Module.cwrap(fname, ...decl('nnn:n'));
+    return function(stmt, i, value) {
+      verifyStatement(stmt);
+      const result = f(stmt, i, value);
+      // trace(fname, result);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.bind_int = (function() {
+    const fname = 'sqlite3_bind_int';
+    const f = Module.cwrap(fname, ...decl('nnn:n'));
+    return function(stmt, i, value) {
+      verifyStatement(stmt);
+      if (value > 0x7fffffff || value < -0x80000000) return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE;
+
+      const result = f(stmt, i, value);
+      // trace(fname, result);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.bind_int64 = (function() {
+    const fname = 'sqlite3_bind_int64';
+    const f = Module.cwrap(fname, ...decl('nnnn:n'));
+    return function(stmt, i, value) {
+      verifyStatement(stmt);
+      if (value > MAX_INT64 || value < MIN_INT64) return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE;
+
+      const lo32 = value & 0xffffffffn;
+      const hi32 = value >> 32n;
+      const result = f(stmt, i, Number(lo32), Number(hi32));
+      // trace(fname, result);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.bind_null = (function() {
+    const fname = 'sqlite3_bind_null';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, i) {
+      verifyStatement(stmt);
+      const result = f(stmt, i);
+      // trace(fname, result);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.bind_parameter_name = (function() {
+    const fname = 'sqlite3_bind_parameter_name';
+    const f = Module.cwrap(fname, ...decl('n:s'));
+    return function(stmt, i) {
+      verifyStatement(stmt);
+      const result = f(stmt, i);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.bind_text = (function() {
+    const fname = 'sqlite3_bind_text';
+    const f = Module.cwrap(fname, ...decl('nnnnn:n'));
+    return function(stmt, i, value) {
+      verifyStatement(stmt);
+      const ptr = createUTF8(value);
+      const result = f(stmt, i, ptr, -1, sqliteFreeAddress);
+      // trace(fname, result);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.changes = (function() {
+    const fname = 'sqlite3_changes';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(db) {
+      verifyDatabase(db);
+      const result = f(db);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.last_insert_id = (function() {
+    const fname = 'sqlite3_last_insert_rowid';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(db) {
+      verifyDatabase(db);
+      const result = f(db);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.close = (function() {
+    const fname = 'sqlite3_close';
+    const f = Module.cwrap(fname, ...decl('n:n'), { async });
+    return async function(db) {
+      verifyDatabase(db);
+      const result = await f(db);
+      databases.delete(db);
+      return check(fname, result, db);
+    };
+  })();
+
+  sqlite3.column = function(stmt, iCol) {
+    verifyStatement(stmt);
+    const type = sqlite3.column_type(stmt, iCol);
+    switch (type) {
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BLOB:
+        return sqlite3.column_blob(stmt, iCol);
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FLOAT:
+        return sqlite3.column_double(stmt, iCol);
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTEGER:
+        const lo32 = sqlite3.column_int(stmt, iCol);
+        const hi32 = Module.getTempRet0();
+        return cvt32x2AsSafe(lo32, hi32);
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NULL:
+        return null;
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TEXT:
+        return sqlite3.column_text(stmt, iCol);
+      default:
+        throw new SQLiteError('unknown type', type);
+    }
+  };
+
+  sqlite3.column_blob = (function() {
+    const fname = 'sqlite3_column_blob';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const nBytes = sqlite3.column_bytes(stmt, iCol);
+      const address = f(stmt, iCol);
+      const result = Module.HEAPU8.subarray(address, address + nBytes);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_bytes = (function() {
+    const fname = 'sqlite3_column_bytes';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const result = f(stmt, iCol);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_count = (function() {
+    const fname = 'sqlite3_column_count';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(stmt) {
+      verifyStatement(stmt);
+      const result = f(stmt);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_double = (function() {
+    const fname = 'sqlite3_column_double';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const result = f(stmt, iCol);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_int = (function() {
+    // Retrieve int64 but use only the lower 32 bits. The upper 32-bits are
+    // accessible with Module.getTempRet0().
+    const fname = 'sqlite3_column_int64';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const result = f(stmt, iCol);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_int64 = (function() {
+    const fname = 'sqlite3_column_int64';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const lo32 = f(stmt, iCol);
+      const hi32 = Module.getTempRet0();
+      const result = cvt32x2ToBigInt(lo32, hi32);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_name = (function() {
+    const fname = 'sqlite3_column_name';
+    const f = Module.cwrap(fname, ...decl('nn:s'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const result = f(stmt, iCol);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_names = function(stmt) {
+    const columns = [];
+    const nColumns = sqlite3.column_count(stmt);
+    for (let i = 0; i < nColumns; ++i) {
+      columns.push(sqlite3.column_name(stmt, i));
+    }
+    return columns;
+  };
+
+  sqlite3.column_text = (function() {
+    const fname = 'sqlite3_column_text';
+    const f = Module.cwrap(fname, ...decl('nn:s'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const result = f(stmt, iCol);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.column_type = (function() {
+    const fname = 'sqlite3_column_type';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(stmt, iCol) {
+      verifyStatement(stmt);
+      const result = f(stmt, iCol);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.create_function = function(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal) {
+    verifyDatabase(db);
+    if (xFunc && !xStep && !xFinal) {
+      const result = Module.createFunction(db, zFunctionName, nArg, eTextRep, pApp, xFunc);
+      return check('sqlite3_create_function', result, db);
+    }
+
+    if (!xFunc && xStep && xFinal) {
+      const result = Module.createAggregate(db, zFunctionName, nArg, eTextRep, pApp, xStep, xFinal);
+      return check('sqlite3_create_function', result, db);
+    }
+
+    throw new SQLiteError('invalid function combination', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+  };
+
+  sqlite3.create_module = function(db, zName, module, appData) {
+    verifyDatabase(db);
+    const result = Module.createModule(db, zName, module, appData);
+    return check('sqlite3_create_module', result, db);
+  };
+
+  sqlite3.data_count = (function() {
+    const fname = 'sqlite3_data_count';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(stmt) {
+      verifyStatement(stmt);
+      const result = f(stmt);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.declare_vtab = (function() {
+    const fname = 'sqlite3_declare_vtab';
+    const f = Module.cwrap(fname, ...decl('ns:n'));
+    return function(pVTab, zSQL) {
+      const result = f(pVTab, zSQL);
+      return check('sqlite3_declare_vtab', result);
+    }
+  })();
+
+  sqlite3.exec = async function(db, sql, callback) {
+    for await (const stmt of sqlite3.statements(db, sql)) {
+      let columns;
+      while ((await sqlite3.step(stmt)) === _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW) {
+        if (callback) {
+          columns = columns ?? sqlite3.column_names(stmt);
+          const row = sqlite3.row(stmt);
+          await callback(row, columns);
+        }
+      }
+    }
+    return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK;
+  };
+
+  sqlite3.finalize = (function() {
+    const fname = 'sqlite3_finalize';
+    const f = Module.cwrap(fname, ...decl('n:n'), { async });
+    return async function(stmt) {
+      if (!mapStmtToDB.has(stmt)) {
+        return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE;
+      }
+      const result = await f(stmt);
+
+      const db = mapStmtToDB.get(stmt);
+      mapStmtToDB.delete(stmt);
+
+      // Don't throw on error here. Typically the error has already been
+      // thrown and finalize() is part of the cleanup.
+      return result;
+    };
+  })();
+
+  sqlite3.get_autocommit = (function() {
+    const fname = 'sqlite3_get_autocommit';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(db) {
+      const result = f(db);
+      return result;
+    };
+  })();
+
+  sqlite3.libversion = (function() {
+    const fname = 'sqlite3_libversion';
+    const f = Module.cwrap(fname, ...decl(':s'));
+    return function() {
+      const result = f();
+      return result;
+    };
+  })();
+
+  sqlite3.libversion_number = (function() {
+    const fname = 'sqlite3_libversion_number';
+    const f = Module.cwrap(fname, ...decl(':n'));
+    return function() {
+      const result = f();
+      return result;
+    };
+  })();
+
+  sqlite3.limit = (function() {
+    const fname = 'sqlite3_limit';
+    const f = Module.cwrap(fname, ...decl('nnn:n'));
+    return function(db, id, newVal) {
+      const result = f(db, id, newVal);
+      return result;
+    };
+  })();
+
+  sqlite3.open_v2 = (function() {
+    const fname = 'sqlite3_open_v2';
+    const f = Module.cwrap(fname, ...decl('snnn:n'), { async });
+    return async function(zFilename, flags, zVfs) {
+      flags = flags || _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_CREATE | _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OPEN_READWRITE;
+      zVfs = createUTF8(zVfs);
+      Module.ccall('setup_powersync', 'int', []);
+
+      const result = await f(zFilename, tmpPtr[0], flags, zVfs);
+
+      const db = Module.getValue(tmpPtr[0], '*');
+
+      databases.add(db);
+      Module._sqlite3_free(zVfs);
+
+      Module.ccall('RegisterExtensionFunctions', 'void', ['number'], [db]);
+      check(fname, result);
+      return db;
+    };
+  })();
+
+  sqlite3.register_table_onchange_hook = function(db, callback) {
+    // Register hooks for this DB as a global hook
+    // It will call the global handler above
+    Module.ccall('register_table_update_hook', 'int', ['number'], [db]);
+
+    onTableChangeCallbacks[db] = function(opType, tableNamePtr, rowId) {
+      // Need to get the string from the pointer
+      // const tableName = Module.UTF8ToString(Module.getValue(tableNamePtr, '*'));
+      const memory = new DataView(Module.HEAPU8.buffer);
+
+      // Find the null terminator to determine the string length
+      let length = 0;
+      while (memory.getUint8(tableNamePtr + length) !== 0) {
+        length++;
+      }
+
+      // Extract the string content
+      const stringBytes = new Uint8Array(Module.HEAPU8.buffer, tableNamePtr, length);
+      const tableName = new TextDecoder().decode(stringBytes);
+
+      return callback(opType, tableName, rowId);
+    };
+  };
+
+  sqlite3.prepare_v2 = (function() {
+    const fname = 'sqlite3_prepare_v2';
+    const f = Module.cwrap(fname, ...decl('nnnnn:n'), { async });
+    return async function(db, sql) {
+      const result = await f(db, sql, -1, tmpPtr[0], tmpPtr[1]);
+      check(fname, result, db);
+
+      const stmt = Module.getValue(tmpPtr[0], '*');
+      if (stmt) {
+        mapStmtToDB.set(stmt, db);
+        return { stmt, sql: Module.getValue(tmpPtr[1], '*') };
+      }
+      return null;
+    };
+  })();
+
+  sqlite3.progress_handler = function(db, nProgressOps, handler, userData) {
+    verifyDatabase(db);
+    Module.progressHandler(db, nProgressOps, handler, userData);
+  };
+
+  sqlite3.reset = (function() {
+    const fname = 'sqlite3_reset';
+    const f = Module.cwrap(fname, ...decl('n:n'), { async });
+    return async function(stmt) {
+      verifyStatement(stmt);
+      const result = await f(stmt);
+      return check(fname, result, mapStmtToDB.get(stmt));
+    };
+  })();
+
+  sqlite3.result = function(context, value) {
+    switch (typeof value) {
+      case 'number':
+        if (value === (value | 0)) {
+          sqlite3.result_int(context, value);
+        } else {
+          sqlite3.result_double(context, value);
+        }
+        break;
+      case 'string':
+        sqlite3.result_text(context, value);
+        break;
+      default:
+        if (value instanceof Uint8Array || Array.isArray(value)) {
+          sqlite3.result_blob(context, value);
+        } else if (value === null) {
+          sqlite3.result_null(context);
+        } else if (typeof value === 'bigint') {
+          return sqlite3.result_int64(context, value);
+        } else {
+          console.warn('unknown result converted to null', value);
+          sqlite3.result_null(context);
+        }
+        break;
+    }
+  };
+
+  sqlite3.result_blob = (function() {
+    const fname = 'sqlite3_result_blob';
+    const f = Module.cwrap(fname, ...decl('nnnn:n'));
+    return function(context, value) {
+      // @ts-ignore
+      const byteLength = value.byteLength ?? value.length;
+      const ptr = Module._sqlite3_malloc(byteLength);
+      Module.HEAPU8.subarray(ptr).set(value);
+      f(context, ptr, byteLength, sqliteFreeAddress); // void return
+    };
+  })();
+
+  sqlite3.result_double = (function() {
+    const fname = 'sqlite3_result_double';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(context, value) {
+      f(context, value); // void return
+    };
+  })();
+
+  sqlite3.result_int = (function() {
+    const fname = 'sqlite3_result_int';
+    const f = Module.cwrap(fname, ...decl('nn:n'));
+    return function(context, value) {
+      f(context, value); // void return
+    };
+  })();
+
+  sqlite3.result_int64 = (function() {
+    const fname = 'sqlite3_result_int64';
+    const f = Module.cwrap(fname, ...decl('nnn:n'));
+    return function(context, value) {
+      if (value > MAX_INT64 || value < MIN_INT64) return _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_RANGE;
+
+      const lo32 = value & 0xffffffffn;
+      const hi32 = value >> 32n;
+      f(context, Number(lo32), Number(hi32)); // void return
+    };
+  })();
+
+  sqlite3.result_null = (function() {
+    const fname = 'sqlite3_result_null';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(context) {
+      f(context); // void return
+    };
+  })();
+
+  sqlite3.result_text = (function() {
+    const fname = 'sqlite3_result_text';
+    const f = Module.cwrap(fname, ...decl('nnnn:n'));
+    return function(context, value) {
+      const ptr = createUTF8(value);
+      f(context, ptr, -1, sqliteFreeAddress); // void return
+    };
+  })();
+
+  sqlite3.row = function(stmt) {
+    const row = [];
+    const nColumns = sqlite3.data_count(stmt);
+    for (let i = 0; i < nColumns; ++i) {
+      const value = sqlite3.column(stmt, i);
+
+      // Copy blob if aliasing volatile WebAssembly memory. This avoids an
+      // unnecessary copy if users monkey patch column_blob to copy.
+      // @ts-ignore
+      row.push(value?.buffer === Module.HEAPU8.buffer ? value.slice() : value);
+    }
+    return row;
+  };
+
+  sqlite3.set_authorizer = function(db, authFunction, userData) {
+    verifyDatabase(db);
+    const result = Module.setAuthorizer(db, authFunction, userData);
+    return check('sqlite3_set_authorizer', result, db);
+  };
+
+  sqlite3.sql = (function() {
+    const fname = 'sqlite3_sql';
+    const f = Module.cwrap(fname, ...decl('n:s'));
+    return function(stmt) {
+      verifyStatement(stmt);
+      const result = f(stmt);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.statements = function(db, sql) {
+    return (async function*() {
+      const str = sqlite3.str_new(db, sql);
+      let prepared = { stmt: null, sql: sqlite3.str_value(str) };
+      try {
+        while ((prepared = await sqlite3.prepare_v2(db, prepared.sql))) {
+          // console.log(sqlite3.sql(prepared.stmt));
+          yield prepared.stmt;
+          sqlite3.finalize(prepared.stmt);
+          prepared.stmt = null;
+        }
+      } finally {
+        if (prepared?.stmt) {
+          sqlite3.finalize(prepared.stmt);
+        }
+        sqlite3.str_finish(str);
+      }
+    })();
+  };
+
+  sqlite3.step = (function() {
+    const fname = 'sqlite3_step';
+    const f = Module.cwrap(fname, ...decl('n:n'), { async });
+    return async function(stmt) {
+      verifyStatement(stmt);
+      const result = await f(stmt);
+      return check(fname, result, mapStmtToDB.get(stmt), [_sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_ROW, _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_DONE]);
+    };
+  })();
+
+  // Duplicate some of the SQLite dynamic string API but without
+  // calling SQLite (except for memory allocation). We need some way
+  // to transfer Javascript strings and might as well use an API
+  // that mimics the SQLite API.
+  let stringId = 0;
+  const strings = new Map();
+
+  sqlite3.str_new = function(db, s = '') {
+    const sBytes = Module.lengthBytesUTF8(s);
+    const str = stringId++ & 0xffffffff;
+    const data = {
+      offset: Module._sqlite3_malloc(sBytes + 1),
+      bytes: sBytes
+    };
+    strings.set(str, data);
+    Module.stringToUTF8(s, data.offset, data.bytes + 1);
+    return str;
+  };
+
+  sqlite3.str_appendall = function(str, s) {
+    if (!strings.has(str)) {
+      throw new SQLiteError('not a string', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+    }
+    const data = strings.get(str);
+
+    const sBytes = Module.lengthBytesUTF8(s);
+    const newBytes = data.bytes + sBytes;
+    const newOffset = Module._sqlite3_malloc(newBytes + 1);
+    const newArray = Module.HEAPU8.subarray(newOffset, newOffset + newBytes + 1);
+    newArray.set(Module.HEAPU8.subarray(data.offset, data.offset + data.bytes));
+    Module.stringToUTF8(s, newOffset + data.bytes, sBytes + 1);
+
+    Module._sqlite3_free(data.offset);
+    data.offset = newOffset;
+    data.bytes = newBytes;
+    strings.set(str, data);
+  };
+
+  sqlite3.str_finish = function(str) {
+    if (!strings.has(str)) {
+      throw new SQLiteError('not a string', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+    }
+    const data = strings.get(str);
+    strings.delete(str);
+    Module._sqlite3_free(data.offset);
+  };
+
+  sqlite3.str_value = function(str) {
+    if (!strings.has(str)) {
+      throw new SQLiteError('not a string', _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_MISUSE);
+    }
+    return strings.get(str).offset;
+  };
+
+  sqlite3.user_data = function(context) {
+    return Module.getFunctionUserData(context);
+  };
+
+  sqlite3.value = function(pValue) {
+    const type = sqlite3.value_type(pValue);
+    switch (type) {
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_BLOB:
+        return sqlite3.value_blob(pValue);
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_FLOAT:
+        return sqlite3.value_double(pValue);
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_INTEGER:
+        const lo32 = sqlite3.value_int(pValue);
+        const hi32 = Module.getTempRet0();
+        return cvt32x2AsSafe(lo32, hi32);
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_NULL:
+        return null;
+      case _sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_TEXT:
+        return sqlite3.value_text(pValue);
+      default:
+        throw new SQLiteError('unknown type', type);
+    }
+  };
+
+  sqlite3.value_blob = (function() {
+    const fname = 'sqlite3_value_blob';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pValue) {
+      const nBytes = sqlite3.value_bytes(pValue);
+      const address = f(pValue);
+      const result = Module.HEAPU8.subarray(address, address + nBytes);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.value_bytes = (function() {
+    const fname = 'sqlite3_value_bytes';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pValue) {
+      const result = f(pValue);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.value_double = (function() {
+    const fname = 'sqlite3_value_double';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pValue) {
+      const result = f(pValue);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.value_int = (function() {
+    const fname = 'sqlite3_value_int64';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pValue) {
+      const result = f(pValue);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.value_int64 = (function() {
+    const fname = 'sqlite3_value_int64';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pValue) {
+      const lo32 = f(pValue);
+      const hi32 = Module.getTempRet0();
+      const result = cvt32x2ToBigInt(lo32, hi32);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.value_text = (function() {
+    const fname = 'sqlite3_value_text';
+    const f = Module.cwrap(fname, ...decl('n:s'));
+    return function(pValue) {
+      const result = f(pValue);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.value_type = (function() {
+    const fname = 'sqlite3_value_type';
+    const f = Module.cwrap(fname, ...decl('n:n'));
+    return function(pValue) {
+      const result = f(pValue);
+      // trace(fname, result);
+      return result;
+    };
+  })();
+
+  sqlite3.vfs_register = function(vfs, makeDefault) {
+    const result = Module.registerVFS(vfs, makeDefault);
+    return check('sqlite3_vfs_register', result);
+  };
+
+  function check(fname, result, db = null, allowed = [_sqlite_constants_js__WEBPACK_IMPORTED_MODULE_0__.SQLITE_OK]) {
+    // trace(fname, result);
+    if (allowed.includes(result)) return result;
+    const message = db ? Module.ccall('sqlite3_errmsg', 'string', ['number'], [db]) : fname;
+    throw new SQLiteError(message, result);
+  }
+
+  return sqlite3;
+}
+
+function trace(...args) {
+  // const date = new Date();
+  // const t = date.getHours().toString().padStart(2, '0') + ':' +
+  //           date.getMinutes().toString().padStart(2, '0') + ':' +
+  //           date.getSeconds().toString().padStart(2, '0') + '.' +
+  //           date.getMilliseconds().toString().padStart(3, '0');
+  // console.debug(t, ...args);
+}
+
+// Helper function to use a more compact signature specification.
+function decl(s) {
+  const result = [];
+  const m = s.match(/([ns@]*):([nsv@])/);
+  switch (m[2]) {
+    case 'n':
+      result.push('number');
+      break;
+    case 's':
+      result.push('string');
+      break;
+    case 'v':
+      result.push(null);
+      break;
+  }
+
+  const args = [];
+  for (let c of m[1]) {
+    switch (c) {
+      case 'n':
+        args.push('number');
+        break;
+      case 's':
+        args.push('string');
+        break;
+    }
+  }
+  result.push(args);
+  return result;
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-constants.js":
+/*!*************************************************************************!*\
+  !*** ../../node_modules/@journeyapps/wa-sqlite/src/sqlite-constants.js ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   SQLITE_ABORT: () => (/* binding */ SQLITE_ABORT),
+/* harmony export */   SQLITE_ACCESS_EXISTS: () => (/* binding */ SQLITE_ACCESS_EXISTS),
+/* harmony export */   SQLITE_ACCESS_READ: () => (/* binding */ SQLITE_ACCESS_READ),
+/* harmony export */   SQLITE_ACCESS_READWRITE: () => (/* binding */ SQLITE_ACCESS_READWRITE),
+/* harmony export */   SQLITE_ALTER_TABLE: () => (/* binding */ SQLITE_ALTER_TABLE),
+/* harmony export */   SQLITE_ANALYZE: () => (/* binding */ SQLITE_ANALYZE),
+/* harmony export */   SQLITE_ATTACH: () => (/* binding */ SQLITE_ATTACH),
+/* harmony export */   SQLITE_AUTH: () => (/* binding */ SQLITE_AUTH),
+/* harmony export */   SQLITE_BLOB: () => (/* binding */ SQLITE_BLOB),
+/* harmony export */   SQLITE_BUSY: () => (/* binding */ SQLITE_BUSY),
+/* harmony export */   SQLITE_CANTOPEN: () => (/* binding */ SQLITE_CANTOPEN),
+/* harmony export */   SQLITE_CONSTRAINT: () => (/* binding */ SQLITE_CONSTRAINT),
+/* harmony export */   SQLITE_CONSTRAINT_CHECK: () => (/* binding */ SQLITE_CONSTRAINT_CHECK),
+/* harmony export */   SQLITE_CONSTRAINT_COMMITHOOK: () => (/* binding */ SQLITE_CONSTRAINT_COMMITHOOK),
+/* harmony export */   SQLITE_CONSTRAINT_FOREIGNKEY: () => (/* binding */ SQLITE_CONSTRAINT_FOREIGNKEY),
+/* harmony export */   SQLITE_CONSTRAINT_FUNCTION: () => (/* binding */ SQLITE_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_CONSTRAINT_NOTNULL: () => (/* binding */ SQLITE_CONSTRAINT_NOTNULL),
+/* harmony export */   SQLITE_CONSTRAINT_PINNED: () => (/* binding */ SQLITE_CONSTRAINT_PINNED),
+/* harmony export */   SQLITE_CONSTRAINT_PRIMARYKEY: () => (/* binding */ SQLITE_CONSTRAINT_PRIMARYKEY),
+/* harmony export */   SQLITE_CONSTRAINT_ROWID: () => (/* binding */ SQLITE_CONSTRAINT_ROWID),
+/* harmony export */   SQLITE_CONSTRAINT_TRIGGER: () => (/* binding */ SQLITE_CONSTRAINT_TRIGGER),
+/* harmony export */   SQLITE_CONSTRAINT_UNIQUE: () => (/* binding */ SQLITE_CONSTRAINT_UNIQUE),
+/* harmony export */   SQLITE_CONSTRAINT_VTAB: () => (/* binding */ SQLITE_CONSTRAINT_VTAB),
+/* harmony export */   SQLITE_COPY: () => (/* binding */ SQLITE_COPY),
+/* harmony export */   SQLITE_CORRUPT: () => (/* binding */ SQLITE_CORRUPT),
+/* harmony export */   SQLITE_CREATE_INDEX: () => (/* binding */ SQLITE_CREATE_INDEX),
+/* harmony export */   SQLITE_CREATE_TABLE: () => (/* binding */ SQLITE_CREATE_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_INDEX: () => (/* binding */ SQLITE_CREATE_TEMP_INDEX),
+/* harmony export */   SQLITE_CREATE_TEMP_TABLE: () => (/* binding */ SQLITE_CREATE_TEMP_TABLE),
+/* harmony export */   SQLITE_CREATE_TEMP_TRIGGER: () => (/* binding */ SQLITE_CREATE_TEMP_TRIGGER),
+/* harmony export */   SQLITE_CREATE_TEMP_VIEW: () => (/* binding */ SQLITE_CREATE_TEMP_VIEW),
+/* harmony export */   SQLITE_CREATE_TRIGGER: () => (/* binding */ SQLITE_CREATE_TRIGGER),
+/* harmony export */   SQLITE_CREATE_VIEW: () => (/* binding */ SQLITE_CREATE_VIEW),
+/* harmony export */   SQLITE_CREATE_VTABLE: () => (/* binding */ SQLITE_CREATE_VTABLE),
+/* harmony export */   SQLITE_DELETE: () => (/* binding */ SQLITE_DELETE),
+/* harmony export */   SQLITE_DENY: () => (/* binding */ SQLITE_DENY),
+/* harmony export */   SQLITE_DETACH: () => (/* binding */ SQLITE_DETACH),
+/* harmony export */   SQLITE_DETERMINISTIC: () => (/* binding */ SQLITE_DETERMINISTIC),
+/* harmony export */   SQLITE_DIRECTONLY: () => (/* binding */ SQLITE_DIRECTONLY),
+/* harmony export */   SQLITE_DONE: () => (/* binding */ SQLITE_DONE),
+/* harmony export */   SQLITE_DROP_INDEX: () => (/* binding */ SQLITE_DROP_INDEX),
+/* harmony export */   SQLITE_DROP_TABLE: () => (/* binding */ SQLITE_DROP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_INDEX: () => (/* binding */ SQLITE_DROP_TEMP_INDEX),
+/* harmony export */   SQLITE_DROP_TEMP_TABLE: () => (/* binding */ SQLITE_DROP_TEMP_TABLE),
+/* harmony export */   SQLITE_DROP_TEMP_TRIGGER: () => (/* binding */ SQLITE_DROP_TEMP_TRIGGER),
+/* harmony export */   SQLITE_DROP_TEMP_VIEW: () => (/* binding */ SQLITE_DROP_TEMP_VIEW),
+/* harmony export */   SQLITE_DROP_TRIGGER: () => (/* binding */ SQLITE_DROP_TRIGGER),
+/* harmony export */   SQLITE_DROP_VIEW: () => (/* binding */ SQLITE_DROP_VIEW),
+/* harmony export */   SQLITE_DROP_VTABLE: () => (/* binding */ SQLITE_DROP_VTABLE),
+/* harmony export */   SQLITE_EMPTY: () => (/* binding */ SQLITE_EMPTY),
+/* harmony export */   SQLITE_ERROR: () => (/* binding */ SQLITE_ERROR),
+/* harmony export */   SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: () => (/* binding */ SQLITE_FCNTL_BEGIN_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_BUSYHANDLER: () => (/* binding */ SQLITE_FCNTL_BUSYHANDLER),
+/* harmony export */   SQLITE_FCNTL_CHUNK_SIZE: () => (/* binding */ SQLITE_FCNTL_CHUNK_SIZE),
+/* harmony export */   SQLITE_FCNTL_CKPT_DONE: () => (/* binding */ SQLITE_FCNTL_CKPT_DONE),
+/* harmony export */   SQLITE_FCNTL_CKPT_START: () => (/* binding */ SQLITE_FCNTL_CKPT_START),
+/* harmony export */   SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: () => (/* binding */ SQLITE_FCNTL_COMMIT_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_COMMIT_PHASETWO: () => (/* binding */ SQLITE_FCNTL_COMMIT_PHASETWO),
+/* harmony export */   SQLITE_FCNTL_DATA_VERSION: () => (/* binding */ SQLITE_FCNTL_DATA_VERSION),
+/* harmony export */   SQLITE_FCNTL_FILE_POINTER: () => (/* binding */ SQLITE_FCNTL_FILE_POINTER),
+/* harmony export */   SQLITE_FCNTL_GET_LOCKPROXYFILE: () => (/* binding */ SQLITE_FCNTL_GET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_HAS_MOVED: () => (/* binding */ SQLITE_FCNTL_HAS_MOVED),
+/* harmony export */   SQLITE_FCNTL_JOURNAL_POINTER: () => (/* binding */ SQLITE_FCNTL_JOURNAL_POINTER),
+/* harmony export */   SQLITE_FCNTL_LAST_ERRNO: () => (/* binding */ SQLITE_FCNTL_LAST_ERRNO),
+/* harmony export */   SQLITE_FCNTL_LOCKSTATE: () => (/* binding */ SQLITE_FCNTL_LOCKSTATE),
+/* harmony export */   SQLITE_FCNTL_LOCK_TIMEOUT: () => (/* binding */ SQLITE_FCNTL_LOCK_TIMEOUT),
+/* harmony export */   SQLITE_FCNTL_MMAP_SIZE: () => (/* binding */ SQLITE_FCNTL_MMAP_SIZE),
+/* harmony export */   SQLITE_FCNTL_OVERWRITE: () => (/* binding */ SQLITE_FCNTL_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PDB: () => (/* binding */ SQLITE_FCNTL_PDB),
+/* harmony export */   SQLITE_FCNTL_PERSIST_WAL: () => (/* binding */ SQLITE_FCNTL_PERSIST_WAL),
+/* harmony export */   SQLITE_FCNTL_POWERSAFE_OVERWRITE: () => (/* binding */ SQLITE_FCNTL_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_FCNTL_PRAGMA: () => (/* binding */ SQLITE_FCNTL_PRAGMA),
+/* harmony export */   SQLITE_FCNTL_RBU: () => (/* binding */ SQLITE_FCNTL_RBU),
+/* harmony export */   SQLITE_FCNTL_RESERVE_BYTES: () => (/* binding */ SQLITE_FCNTL_RESERVE_BYTES),
+/* harmony export */   SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: () => (/* binding */ SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE),
+/* harmony export */   SQLITE_FCNTL_SET_LOCKPROXYFILE: () => (/* binding */ SQLITE_FCNTL_SET_LOCKPROXYFILE),
+/* harmony export */   SQLITE_FCNTL_SIZE_HINT: () => (/* binding */ SQLITE_FCNTL_SIZE_HINT),
+/* harmony export */   SQLITE_FCNTL_SIZE_LIMIT: () => (/* binding */ SQLITE_FCNTL_SIZE_LIMIT),
+/* harmony export */   SQLITE_FCNTL_SYNC: () => (/* binding */ SQLITE_FCNTL_SYNC),
+/* harmony export */   SQLITE_FCNTL_SYNC_OMITTED: () => (/* binding */ SQLITE_FCNTL_SYNC_OMITTED),
+/* harmony export */   SQLITE_FCNTL_TEMPFILENAME: () => (/* binding */ SQLITE_FCNTL_TEMPFILENAME),
+/* harmony export */   SQLITE_FCNTL_TRACE: () => (/* binding */ SQLITE_FCNTL_TRACE),
+/* harmony export */   SQLITE_FCNTL_VFSNAME: () => (/* binding */ SQLITE_FCNTL_VFSNAME),
+/* harmony export */   SQLITE_FCNTL_VFS_POINTER: () => (/* binding */ SQLITE_FCNTL_VFS_POINTER),
+/* harmony export */   SQLITE_FCNTL_WAL_BLOCK: () => (/* binding */ SQLITE_FCNTL_WAL_BLOCK),
+/* harmony export */   SQLITE_FCNTL_WIN32_AV_RETRY: () => (/* binding */ SQLITE_FCNTL_WIN32_AV_RETRY),
+/* harmony export */   SQLITE_FCNTL_WIN32_GET_HANDLE: () => (/* binding */ SQLITE_FCNTL_WIN32_GET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_WIN32_SET_HANDLE: () => (/* binding */ SQLITE_FCNTL_WIN32_SET_HANDLE),
+/* harmony export */   SQLITE_FCNTL_ZIPVFS: () => (/* binding */ SQLITE_FCNTL_ZIPVFS),
+/* harmony export */   SQLITE_FLOAT: () => (/* binding */ SQLITE_FLOAT),
+/* harmony export */   SQLITE_FORMAT: () => (/* binding */ SQLITE_FORMAT),
+/* harmony export */   SQLITE_FULL: () => (/* binding */ SQLITE_FULL),
+/* harmony export */   SQLITE_FUNCTION: () => (/* binding */ SQLITE_FUNCTION),
+/* harmony export */   SQLITE_IGNORE: () => (/* binding */ SQLITE_IGNORE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_EQ: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_EQ),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_FUNCTION: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_FUNCTION),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GE: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_GE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GLOB: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_GLOB),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_GT: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_GT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_IS: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_IS),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOT: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_ISNOT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNOTNULL: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_ISNOTNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_ISNULL: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_ISNULL),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LE: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_LE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LIKE: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_LIKE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_LT: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_LT),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_MATCH: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_MATCH),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_NE: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_NE),
+/* harmony export */   SQLITE_INDEX_CONSTRAINT_REGEXP: () => (/* binding */ SQLITE_INDEX_CONSTRAINT_REGEXP),
+/* harmony export */   SQLITE_INDEX_SCAN_UNIQUE: () => (/* binding */ SQLITE_INDEX_SCAN_UNIQUE),
+/* harmony export */   SQLITE_INNOCUOUS: () => (/* binding */ SQLITE_INNOCUOUS),
+/* harmony export */   SQLITE_INSERT: () => (/* binding */ SQLITE_INSERT),
+/* harmony export */   SQLITE_INTEGER: () => (/* binding */ SQLITE_INTEGER),
+/* harmony export */   SQLITE_INTERNAL: () => (/* binding */ SQLITE_INTERNAL),
+/* harmony export */   SQLITE_INTERRUPT: () => (/* binding */ SQLITE_INTERRUPT),
+/* harmony export */   SQLITE_IOCAP_ATOMIC: () => (/* binding */ SQLITE_IOCAP_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_ATOMIC16K: () => (/* binding */ SQLITE_IOCAP_ATOMIC16K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC1K: () => (/* binding */ SQLITE_IOCAP_ATOMIC1K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC2K: () => (/* binding */ SQLITE_IOCAP_ATOMIC2K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC32K: () => (/* binding */ SQLITE_IOCAP_ATOMIC32K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC4K: () => (/* binding */ SQLITE_IOCAP_ATOMIC4K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC512: () => (/* binding */ SQLITE_IOCAP_ATOMIC512),
+/* harmony export */   SQLITE_IOCAP_ATOMIC64K: () => (/* binding */ SQLITE_IOCAP_ATOMIC64K),
+/* harmony export */   SQLITE_IOCAP_ATOMIC8K: () => (/* binding */ SQLITE_IOCAP_ATOMIC8K),
+/* harmony export */   SQLITE_IOCAP_BATCH_ATOMIC: () => (/* binding */ SQLITE_IOCAP_BATCH_ATOMIC),
+/* harmony export */   SQLITE_IOCAP_IMMUTABLE: () => (/* binding */ SQLITE_IOCAP_IMMUTABLE),
+/* harmony export */   SQLITE_IOCAP_POWERSAFE_OVERWRITE: () => (/* binding */ SQLITE_IOCAP_POWERSAFE_OVERWRITE),
+/* harmony export */   SQLITE_IOCAP_SAFE_APPEND: () => (/* binding */ SQLITE_IOCAP_SAFE_APPEND),
+/* harmony export */   SQLITE_IOCAP_SEQUENTIAL: () => (/* binding */ SQLITE_IOCAP_SEQUENTIAL),
+/* harmony export */   SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: () => (/* binding */ SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN),
+/* harmony export */   SQLITE_IOERR: () => (/* binding */ SQLITE_IOERR),
+/* harmony export */   SQLITE_IOERR_ACCESS: () => (/* binding */ SQLITE_IOERR_ACCESS),
+/* harmony export */   SQLITE_IOERR_BEGIN_ATOMIC: () => (/* binding */ SQLITE_IOERR_BEGIN_ATOMIC),
+/* harmony export */   SQLITE_IOERR_CHECKRESERVEDLOCK: () => (/* binding */ SQLITE_IOERR_CHECKRESERVEDLOCK),
+/* harmony export */   SQLITE_IOERR_CLOSE: () => (/* binding */ SQLITE_IOERR_CLOSE),
+/* harmony export */   SQLITE_IOERR_COMMIT_ATOMIC: () => (/* binding */ SQLITE_IOERR_COMMIT_ATOMIC),
+/* harmony export */   SQLITE_IOERR_DATA: () => (/* binding */ SQLITE_IOERR_DATA),
+/* harmony export */   SQLITE_IOERR_DELETE: () => (/* binding */ SQLITE_IOERR_DELETE),
+/* harmony export */   SQLITE_IOERR_DELETE_NOENT: () => (/* binding */ SQLITE_IOERR_DELETE_NOENT),
+/* harmony export */   SQLITE_IOERR_DIR_FSYNC: () => (/* binding */ SQLITE_IOERR_DIR_FSYNC),
+/* harmony export */   SQLITE_IOERR_FSTAT: () => (/* binding */ SQLITE_IOERR_FSTAT),
+/* harmony export */   SQLITE_IOERR_FSYNC: () => (/* binding */ SQLITE_IOERR_FSYNC),
+/* harmony export */   SQLITE_IOERR_GETTEMPPATH: () => (/* binding */ SQLITE_IOERR_GETTEMPPATH),
+/* harmony export */   SQLITE_IOERR_LOCK: () => (/* binding */ SQLITE_IOERR_LOCK),
+/* harmony export */   SQLITE_IOERR_NOMEM: () => (/* binding */ SQLITE_IOERR_NOMEM),
+/* harmony export */   SQLITE_IOERR_RDLOCK: () => (/* binding */ SQLITE_IOERR_RDLOCK),
+/* harmony export */   SQLITE_IOERR_READ: () => (/* binding */ SQLITE_IOERR_READ),
+/* harmony export */   SQLITE_IOERR_ROLLBACK_ATOMIC: () => (/* binding */ SQLITE_IOERR_ROLLBACK_ATOMIC),
+/* harmony export */   SQLITE_IOERR_SEEK: () => (/* binding */ SQLITE_IOERR_SEEK),
+/* harmony export */   SQLITE_IOERR_SHORT_READ: () => (/* binding */ SQLITE_IOERR_SHORT_READ),
+/* harmony export */   SQLITE_IOERR_TRUNCATE: () => (/* binding */ SQLITE_IOERR_TRUNCATE),
+/* harmony export */   SQLITE_IOERR_UNLOCK: () => (/* binding */ SQLITE_IOERR_UNLOCK),
+/* harmony export */   SQLITE_IOERR_VNODE: () => (/* binding */ SQLITE_IOERR_VNODE),
+/* harmony export */   SQLITE_IOERR_WRITE: () => (/* binding */ SQLITE_IOERR_WRITE),
+/* harmony export */   SQLITE_LIMIT_ATTACHED: () => (/* binding */ SQLITE_LIMIT_ATTACHED),
+/* harmony export */   SQLITE_LIMIT_COLUMN: () => (/* binding */ SQLITE_LIMIT_COLUMN),
+/* harmony export */   SQLITE_LIMIT_COMPOUND_SELECT: () => (/* binding */ SQLITE_LIMIT_COMPOUND_SELECT),
+/* harmony export */   SQLITE_LIMIT_EXPR_DEPTH: () => (/* binding */ SQLITE_LIMIT_EXPR_DEPTH),
+/* harmony export */   SQLITE_LIMIT_FUNCTION_ARG: () => (/* binding */ SQLITE_LIMIT_FUNCTION_ARG),
+/* harmony export */   SQLITE_LIMIT_LENGTH: () => (/* binding */ SQLITE_LIMIT_LENGTH),
+/* harmony export */   SQLITE_LIMIT_LIKE_PATTERN_LENGTH: () => (/* binding */ SQLITE_LIMIT_LIKE_PATTERN_LENGTH),
+/* harmony export */   SQLITE_LIMIT_SQL_LENGTH: () => (/* binding */ SQLITE_LIMIT_SQL_LENGTH),
+/* harmony export */   SQLITE_LIMIT_TRIGGER_DEPTH: () => (/* binding */ SQLITE_LIMIT_TRIGGER_DEPTH),
+/* harmony export */   SQLITE_LIMIT_VARIABLE_NUMBER: () => (/* binding */ SQLITE_LIMIT_VARIABLE_NUMBER),
+/* harmony export */   SQLITE_LIMIT_VDBE_OP: () => (/* binding */ SQLITE_LIMIT_VDBE_OP),
+/* harmony export */   SQLITE_LIMIT_WORKER_THREADS: () => (/* binding */ SQLITE_LIMIT_WORKER_THREADS),
+/* harmony export */   SQLITE_LOCKED: () => (/* binding */ SQLITE_LOCKED),
+/* harmony export */   SQLITE_LOCK_EXCLUSIVE: () => (/* binding */ SQLITE_LOCK_EXCLUSIVE),
+/* harmony export */   SQLITE_LOCK_NONE: () => (/* binding */ SQLITE_LOCK_NONE),
+/* harmony export */   SQLITE_LOCK_PENDING: () => (/* binding */ SQLITE_LOCK_PENDING),
+/* harmony export */   SQLITE_LOCK_RESERVED: () => (/* binding */ SQLITE_LOCK_RESERVED),
+/* harmony export */   SQLITE_LOCK_SHARED: () => (/* binding */ SQLITE_LOCK_SHARED),
+/* harmony export */   SQLITE_MISMATCH: () => (/* binding */ SQLITE_MISMATCH),
+/* harmony export */   SQLITE_MISUSE: () => (/* binding */ SQLITE_MISUSE),
+/* harmony export */   SQLITE_NOLFS: () => (/* binding */ SQLITE_NOLFS),
+/* harmony export */   SQLITE_NOMEM: () => (/* binding */ SQLITE_NOMEM),
+/* harmony export */   SQLITE_NOTADB: () => (/* binding */ SQLITE_NOTADB),
+/* harmony export */   SQLITE_NOTFOUND: () => (/* binding */ SQLITE_NOTFOUND),
+/* harmony export */   SQLITE_NOTICE: () => (/* binding */ SQLITE_NOTICE),
+/* harmony export */   SQLITE_NULL: () => (/* binding */ SQLITE_NULL),
+/* harmony export */   SQLITE_OK: () => (/* binding */ SQLITE_OK),
+/* harmony export */   SQLITE_OPEN_AUTOPROXY: () => (/* binding */ SQLITE_OPEN_AUTOPROXY),
+/* harmony export */   SQLITE_OPEN_CREATE: () => (/* binding */ SQLITE_OPEN_CREATE),
+/* harmony export */   SQLITE_OPEN_DELETEONCLOSE: () => (/* binding */ SQLITE_OPEN_DELETEONCLOSE),
+/* harmony export */   SQLITE_OPEN_EXCLUSIVE: () => (/* binding */ SQLITE_OPEN_EXCLUSIVE),
+/* harmony export */   SQLITE_OPEN_FULLMUTEX: () => (/* binding */ SQLITE_OPEN_FULLMUTEX),
+/* harmony export */   SQLITE_OPEN_MAIN_DB: () => (/* binding */ SQLITE_OPEN_MAIN_DB),
+/* harmony export */   SQLITE_OPEN_MAIN_JOURNAL: () => (/* binding */ SQLITE_OPEN_MAIN_JOURNAL),
+/* harmony export */   SQLITE_OPEN_MEMORY: () => (/* binding */ SQLITE_OPEN_MEMORY),
+/* harmony export */   SQLITE_OPEN_NOFOLLOW: () => (/* binding */ SQLITE_OPEN_NOFOLLOW),
+/* harmony export */   SQLITE_OPEN_NOMUTEX: () => (/* binding */ SQLITE_OPEN_NOMUTEX),
+/* harmony export */   SQLITE_OPEN_PRIVATECACHE: () => (/* binding */ SQLITE_OPEN_PRIVATECACHE),
+/* harmony export */   SQLITE_OPEN_READONLY: () => (/* binding */ SQLITE_OPEN_READONLY),
+/* harmony export */   SQLITE_OPEN_READWRITE: () => (/* binding */ SQLITE_OPEN_READWRITE),
+/* harmony export */   SQLITE_OPEN_SHAREDCACHE: () => (/* binding */ SQLITE_OPEN_SHAREDCACHE),
+/* harmony export */   SQLITE_OPEN_SUBJOURNAL: () => (/* binding */ SQLITE_OPEN_SUBJOURNAL),
+/* harmony export */   SQLITE_OPEN_SUPER_JOURNAL: () => (/* binding */ SQLITE_OPEN_SUPER_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TEMP_DB: () => (/* binding */ SQLITE_OPEN_TEMP_DB),
+/* harmony export */   SQLITE_OPEN_TEMP_JOURNAL: () => (/* binding */ SQLITE_OPEN_TEMP_JOURNAL),
+/* harmony export */   SQLITE_OPEN_TRANSIENT_DB: () => (/* binding */ SQLITE_OPEN_TRANSIENT_DB),
+/* harmony export */   SQLITE_OPEN_URI: () => (/* binding */ SQLITE_OPEN_URI),
+/* harmony export */   SQLITE_OPEN_WAL: () => (/* binding */ SQLITE_OPEN_WAL),
+/* harmony export */   SQLITE_PERM: () => (/* binding */ SQLITE_PERM),
+/* harmony export */   SQLITE_PRAGMA: () => (/* binding */ SQLITE_PRAGMA),
+/* harmony export */   SQLITE_PROTOCOL: () => (/* binding */ SQLITE_PROTOCOL),
+/* harmony export */   SQLITE_RANGE: () => (/* binding */ SQLITE_RANGE),
+/* harmony export */   SQLITE_READ: () => (/* binding */ SQLITE_READ),
+/* harmony export */   SQLITE_READONLY: () => (/* binding */ SQLITE_READONLY),
+/* harmony export */   SQLITE_RECURSIVE: () => (/* binding */ SQLITE_RECURSIVE),
+/* harmony export */   SQLITE_REINDEX: () => (/* binding */ SQLITE_REINDEX),
+/* harmony export */   SQLITE_ROW: () => (/* binding */ SQLITE_ROW),
+/* harmony export */   SQLITE_SAVEPOINT: () => (/* binding */ SQLITE_SAVEPOINT),
+/* harmony export */   SQLITE_SCHEMA: () => (/* binding */ SQLITE_SCHEMA),
+/* harmony export */   SQLITE_SELECT: () => (/* binding */ SQLITE_SELECT),
+/* harmony export */   SQLITE_STATIC: () => (/* binding */ SQLITE_STATIC),
+/* harmony export */   SQLITE_SUBTYPE: () => (/* binding */ SQLITE_SUBTYPE),
+/* harmony export */   SQLITE_SYNC_DATAONLY: () => (/* binding */ SQLITE_SYNC_DATAONLY),
+/* harmony export */   SQLITE_SYNC_FULL: () => (/* binding */ SQLITE_SYNC_FULL),
+/* harmony export */   SQLITE_SYNC_NORMAL: () => (/* binding */ SQLITE_SYNC_NORMAL),
+/* harmony export */   SQLITE_TEXT: () => (/* binding */ SQLITE_TEXT),
+/* harmony export */   SQLITE_TOOBIG: () => (/* binding */ SQLITE_TOOBIG),
+/* harmony export */   SQLITE_TRANSACTION: () => (/* binding */ SQLITE_TRANSACTION),
+/* harmony export */   SQLITE_TRANSIENT: () => (/* binding */ SQLITE_TRANSIENT),
+/* harmony export */   SQLITE_UPDATE: () => (/* binding */ SQLITE_UPDATE),
+/* harmony export */   SQLITE_UTF16: () => (/* binding */ SQLITE_UTF16),
+/* harmony export */   SQLITE_UTF16BE: () => (/* binding */ SQLITE_UTF16BE),
+/* harmony export */   SQLITE_UTF16LE: () => (/* binding */ SQLITE_UTF16LE),
+/* harmony export */   SQLITE_UTF8: () => (/* binding */ SQLITE_UTF8),
+/* harmony export */   SQLITE_WARNING: () => (/* binding */ SQLITE_WARNING)
+/* harmony export */ });
+// Primary result codes.
+// https://www.sqlite.org/rescode.html
+const SQLITE_OK = 0;
+const SQLITE_ERROR = 1;
+const SQLITE_INTERNAL = 2;
+const SQLITE_PERM = 3;
+const SQLITE_ABORT = 4;
+const SQLITE_BUSY = 5;
+const SQLITE_LOCKED = 6;
+const SQLITE_NOMEM = 7;
+const SQLITE_READONLY = 8;
+const SQLITE_INTERRUPT = 9;
+const SQLITE_IOERR = 10;
+const SQLITE_CORRUPT = 11;
+const SQLITE_NOTFOUND = 12;
+const SQLITE_FULL = 13;
+const SQLITE_CANTOPEN = 14;
+const SQLITE_PROTOCOL = 15;
+const SQLITE_EMPTY = 16;
+const SQLITE_SCHEMA = 17;
+const SQLITE_TOOBIG = 18;
+const SQLITE_CONSTRAINT = 19;
+const SQLITE_MISMATCH = 20;
+const SQLITE_MISUSE = 21;
+const SQLITE_NOLFS = 22;
+const SQLITE_AUTH = 23;
+const SQLITE_FORMAT = 24;
+const SQLITE_RANGE = 25;
+const SQLITE_NOTADB = 26;
+const SQLITE_NOTICE = 27;
+const SQLITE_WARNING = 28;
+const SQLITE_ROW = 100;
+const SQLITE_DONE = 101;
+
+// Extended error codes.
+const SQLITE_IOERR_ACCESS = 3338;
+const SQLITE_IOERR_CHECKRESERVEDLOCK = 3594;
+const SQLITE_IOERR_CLOSE = 4106;
+const SQLITE_IOERR_DATA = 8202;
+const SQLITE_IOERR_DELETE = 2570;
+const SQLITE_IOERR_DELETE_NOENT = 5898;
+const SQLITE_IOERR_DIR_FSYNC = 1290;
+const SQLITE_IOERR_FSTAT = 1802;
+const SQLITE_IOERR_FSYNC = 1034;
+const SQLITE_IOERR_GETTEMPPATH = 6410;
+const SQLITE_IOERR_LOCK = 3850;
+const SQLITE_IOERR_NOMEM = 3082;
+const SQLITE_IOERR_READ = 266;
+const SQLITE_IOERR_RDLOCK = 2314;
+const SQLITE_IOERR_SEEK = 5642;
+const SQLITE_IOERR_SHORT_READ = 522;
+const SQLITE_IOERR_TRUNCATE = 1546;
+const SQLITE_IOERR_UNLOCK = 2058;
+const SQLITE_IOERR_VNODE = 6922;
+const SQLITE_IOERR_WRITE = 778;
+const SQLITE_IOERR_BEGIN_ATOMIC = 7434;
+const SQLITE_IOERR_COMMIT_ATOMIC = 7690;
+const SQLITE_IOERR_ROLLBACK_ATOMIC = 7946;
+
+// Other extended result codes.
+const SQLITE_CONSTRAINT_CHECK = 275;
+const SQLITE_CONSTRAINT_COMMITHOOK = 531;
+const SQLITE_CONSTRAINT_FOREIGNKEY = 787;
+const SQLITE_CONSTRAINT_FUNCTION = 1043;
+const SQLITE_CONSTRAINT_NOTNULL = 1299;
+const SQLITE_CONSTRAINT_PINNED = 2835;
+const SQLITE_CONSTRAINT_PRIMARYKEY = 1555;
+const SQLITE_CONSTRAINT_ROWID = 2579;
+const SQLITE_CONSTRAINT_TRIGGER = 1811;
+const SQLITE_CONSTRAINT_UNIQUE = 2067;
+const SQLITE_CONSTRAINT_VTAB = 2323;
+
+// Open flags.
+// https://www.sqlite.org/c3ref/c_open_autoproxy.html
+const SQLITE_OPEN_READONLY = 0x00000001;
+const SQLITE_OPEN_READWRITE = 0x00000002;
+const SQLITE_OPEN_CREATE = 0x00000004;
+const SQLITE_OPEN_DELETEONCLOSE = 0x00000008;
+const SQLITE_OPEN_EXCLUSIVE = 0x00000010;
+const SQLITE_OPEN_AUTOPROXY = 0x00000020;
+const SQLITE_OPEN_URI = 0x00000040;
+const SQLITE_OPEN_MEMORY = 0x00000080;
+const SQLITE_OPEN_MAIN_DB = 0x00000100;
+const SQLITE_OPEN_TEMP_DB = 0x00000200;
+const SQLITE_OPEN_TRANSIENT_DB = 0x00000400;
+const SQLITE_OPEN_MAIN_JOURNAL = 0x00000800;
+const SQLITE_OPEN_TEMP_JOURNAL = 0x00001000;
+const SQLITE_OPEN_SUBJOURNAL = 0x00002000;
+const SQLITE_OPEN_SUPER_JOURNAL = 0x00004000;
+const SQLITE_OPEN_NOMUTEX = 0x00008000;
+const SQLITE_OPEN_FULLMUTEX = 0x00010000;
+const SQLITE_OPEN_SHAREDCACHE = 0x00020000;
+const SQLITE_OPEN_PRIVATECACHE = 0x00040000;
+const SQLITE_OPEN_WAL = 0x00080000;
+const SQLITE_OPEN_NOFOLLOW = 0x01000000;
+
+// Locking levels.
+// https://www.sqlite.org/c3ref/c_lock_exclusive.html
+const SQLITE_LOCK_NONE = 0;
+const SQLITE_LOCK_SHARED = 1;
+const SQLITE_LOCK_RESERVED = 2;
+const SQLITE_LOCK_PENDING = 3;
+const SQLITE_LOCK_EXCLUSIVE = 4;
+
+// Device characteristics.
+// https://www.sqlite.org/c3ref/c_iocap_atomic.html
+const SQLITE_IOCAP_ATOMIC = 0x00000001;
+const SQLITE_IOCAP_ATOMIC512 = 0x00000002;
+const SQLITE_IOCAP_ATOMIC1K = 0x00000004;
+const SQLITE_IOCAP_ATOMIC2K = 0x00000008;
+const SQLITE_IOCAP_ATOMIC4K = 0x00000010;
+const SQLITE_IOCAP_ATOMIC8K = 0x00000020;
+const SQLITE_IOCAP_ATOMIC16K = 0x00000040;
+const SQLITE_IOCAP_ATOMIC32K = 0x00000080;
+const SQLITE_IOCAP_ATOMIC64K = 0x00000100;
+const SQLITE_IOCAP_SAFE_APPEND = 0x00000200;
+const SQLITE_IOCAP_SEQUENTIAL = 0x00000400;
+const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN = 0x00000800;
+const SQLITE_IOCAP_POWERSAFE_OVERWRITE = 0x00001000;
+const SQLITE_IOCAP_IMMUTABLE = 0x00002000;
+const SQLITE_IOCAP_BATCH_ATOMIC = 0x00004000;
+
+// xAccess flags.
+// https://www.sqlite.org/c3ref/c_access_exists.html
+const SQLITE_ACCESS_EXISTS = 0;
+const SQLITE_ACCESS_READWRITE = 1;
+const SQLITE_ACCESS_READ = 2;
+
+// File control opcodes
+// https://www.sqlite.org/c3ref/c_fcntl_begin_atomic_write.html#sqlitefcntlbeginatomicwrite
+const SQLITE_FCNTL_LOCKSTATE = 1; 
+const SQLITE_FCNTL_GET_LOCKPROXYFILE = 2; 
+const SQLITE_FCNTL_SET_LOCKPROXYFILE = 3; 
+const SQLITE_FCNTL_LAST_ERRNO = 4; 
+const SQLITE_FCNTL_SIZE_HINT = 5; 
+const SQLITE_FCNTL_CHUNK_SIZE = 6; 
+const SQLITE_FCNTL_FILE_POINTER = 7; 
+const SQLITE_FCNTL_SYNC_OMITTED = 8; 
+const SQLITE_FCNTL_WIN32_AV_RETRY = 9; 
+const SQLITE_FCNTL_PERSIST_WAL = 10; 
+const SQLITE_FCNTL_OVERWRITE = 11; 
+const SQLITE_FCNTL_VFSNAME = 12; 
+const SQLITE_FCNTL_POWERSAFE_OVERWRITE = 13; 
+const SQLITE_FCNTL_PRAGMA = 14; 
+const SQLITE_FCNTL_BUSYHANDLER = 15; 
+const SQLITE_FCNTL_TEMPFILENAME = 16; 
+const SQLITE_FCNTL_MMAP_SIZE = 18; 
+const SQLITE_FCNTL_TRACE = 19; 
+const SQLITE_FCNTL_HAS_MOVED = 20; 
+const SQLITE_FCNTL_SYNC = 21; 
+const SQLITE_FCNTL_COMMIT_PHASETWO = 22; 
+const SQLITE_FCNTL_WIN32_SET_HANDLE = 23; 
+const SQLITE_FCNTL_WAL_BLOCK = 24; 
+const SQLITE_FCNTL_ZIPVFS = 25; 
+const SQLITE_FCNTL_RBU = 26; 
+const SQLITE_FCNTL_VFS_POINTER = 27; 
+const SQLITE_FCNTL_JOURNAL_POINTER = 28; 
+const SQLITE_FCNTL_WIN32_GET_HANDLE = 29; 
+const SQLITE_FCNTL_PDB = 30; 
+const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE = 31; 
+const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE = 32; 
+const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE = 33; 
+const SQLITE_FCNTL_LOCK_TIMEOUT = 34; 
+const SQLITE_FCNTL_DATA_VERSION = 35; 
+const SQLITE_FCNTL_SIZE_LIMIT = 36; 
+const SQLITE_FCNTL_CKPT_DONE = 37; 
+const SQLITE_FCNTL_RESERVE_BYTES = 38; 
+const SQLITE_FCNTL_CKPT_START = 39;
+
+// Fundamental datatypes.
+// https://www.sqlite.org/c3ref/c_blob.html
+const SQLITE_INTEGER = 1;
+const SQLITE_FLOAT = 2;
+const SQLITE_TEXT = 3;
+const SQLITE_BLOB = 4;
+const SQLITE_NULL = 5;
+
+// Special destructor behavior.
+// https://www.sqlite.org/c3ref/c_static.html
+const SQLITE_STATIC = 0;
+const SQLITE_TRANSIENT = -1;
+
+// Text encodings.
+// https://sqlite.org/c3ref/c_any.html
+const SQLITE_UTF8 = 1;     /* IMP: R-37514-35566 */
+const SQLITE_UTF16LE = 2;  /* IMP: R-03371-37637 */
+const SQLITE_UTF16BE = 3;  /* IMP: R-51971-34154 */
+const SQLITE_UTF16 = 4;    /* Use native byte order */
+
+// Module constraint ops.
+const SQLITE_INDEX_CONSTRAINT_EQ        = 2;
+const SQLITE_INDEX_CONSTRAINT_GT        = 4;
+const SQLITE_INDEX_CONSTRAINT_LE        = 8;
+const SQLITE_INDEX_CONSTRAINT_LT        = 16;
+const SQLITE_INDEX_CONSTRAINT_GE        = 32;
+const SQLITE_INDEX_CONSTRAINT_MATCH     = 64;
+const SQLITE_INDEX_CONSTRAINT_LIKE      = 65;
+const SQLITE_INDEX_CONSTRAINT_GLOB      = 66;
+const SQLITE_INDEX_CONSTRAINT_REGEXP    = 67;
+const SQLITE_INDEX_CONSTRAINT_NE        = 68;
+const SQLITE_INDEX_CONSTRAINT_ISNOT     = 69;
+const SQLITE_INDEX_CONSTRAINT_ISNOTNULL = 70;
+const SQLITE_INDEX_CONSTRAINT_ISNULL    = 71;
+const SQLITE_INDEX_CONSTRAINT_IS        = 72;
+const SQLITE_INDEX_CONSTRAINT_FUNCTION  = 150;
+const SQLITE_INDEX_SCAN_UNIQUE          = 1;  /* Scan visits at most = 1 row */
+
+// Function flags
+const SQLITE_DETERMINISTIC = 0x000000800;
+const SQLITE_DIRECTONLY    = 0x000080000;
+const SQLITE_SUBTYPE       = 0x000100000;
+const SQLITE_INNOCUOUS     = 0x000200000;
+
+// Sync flags
+const SQLITE_SYNC_NORMAL   = 0x00002;
+const SQLITE_SYNC_FULL     = 0x00003;
+const SQLITE_SYNC_DATAONLY = 0x00010;
+
+// Authorizer action codes
+const SQLITE_CREATE_INDEX        = 1;
+const SQLITE_CREATE_TABLE        = 2;
+const SQLITE_CREATE_TEMP_INDEX   = 3;
+const SQLITE_CREATE_TEMP_TABLE   = 4;
+const SQLITE_CREATE_TEMP_TRIGGER = 5;
+const SQLITE_CREATE_TEMP_VIEW    = 6;
+const SQLITE_CREATE_TRIGGER      = 7;
+const SQLITE_CREATE_VIEW         = 8;
+const SQLITE_DELETE              = 9;
+const SQLITE_DROP_INDEX          = 10;
+const SQLITE_DROP_TABLE          = 11;
+const SQLITE_DROP_TEMP_INDEX     = 12;
+const SQLITE_DROP_TEMP_TABLE     = 13;
+const SQLITE_DROP_TEMP_TRIGGER   = 14;
+const SQLITE_DROP_TEMP_VIEW      = 15;
+const SQLITE_DROP_TRIGGER        = 16;
+const SQLITE_DROP_VIEW           = 17;
+const SQLITE_INSERT              = 18;
+const SQLITE_PRAGMA              = 19;
+const SQLITE_READ                = 20;
+const SQLITE_SELECT              = 21;
+const SQLITE_TRANSACTION         = 22;
+const SQLITE_UPDATE              = 23;
+const SQLITE_ATTACH              = 24;
+const SQLITE_DETACH              = 25;
+const SQLITE_ALTER_TABLE         = 26;
+const SQLITE_REINDEX             = 27;
+const SQLITE_ANALYZE             = 28;
+const SQLITE_CREATE_VTABLE       = 29;
+const SQLITE_DROP_VTABLE         = 30;
+const SQLITE_FUNCTION            = 31;
+const SQLITE_SAVEPOINT           = 32;
+const SQLITE_COPY                = 0;
+const SQLITE_RECURSIVE           = 33;
+
+// Authorizer return codes
+const SQLITE_DENY   = 1;
+const SQLITE_IGNORE = 2;
+
+// Limit categories
+const SQLITE_LIMIT_LENGTH              = 0;
+const SQLITE_LIMIT_SQL_LENGTH          = 1;
+const SQLITE_LIMIT_COLUMN              = 2;
+const SQLITE_LIMIT_EXPR_DEPTH          = 3;
+const SQLITE_LIMIT_COMPOUND_SELECT     = 4;
+const SQLITE_LIMIT_VDBE_OP             = 5;
+const SQLITE_LIMIT_FUNCTION_ARG        = 6;
+const SQLITE_LIMIT_ATTACHED            = 7;
+const SQLITE_LIMIT_LIKE_PATTERN_LENGTH = 8;
+const SQLITE_LIMIT_VARIABLE_NUMBER     = 9;
+const SQLITE_LIMIT_TRIGGER_DEPTH       = 10;
+const SQLITE_LIMIT_WORKER_THREADS      = 11;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/ensure chunk */
+/******/ 	(() => {
+/******/ 		__webpack_require__.f = {};
+/******/ 		// This file contains only the entry chunk.
+/******/ 		// The chunk loading function for additional chunks
+/******/ 		__webpack_require__.e = (chunkId) => {
+/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
+/******/ 				__webpack_require__.f[key](chunkId, promises);
+/******/ 				return promises;
+/******/ 			}, []));
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/get javascript chunk filename */
+/******/ 	(() => {
+/******/ 		// This function allow to reference async chunks
+/******/ 		__webpack_require__.u = (chunkId) => {
+/******/ 			// return url for filenames based on template
+/******/ 			return "worker/" + chunkId + ".umd.js";
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		var scriptUrl;
+/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+/******/ 		var document = __webpack_require__.g.document;
+/******/ 		if (!scriptUrl && document) {
+/******/ 			if (document.currentScript)
+/******/ 				scriptUrl = document.currentScript.src;
+/******/ 			if (!scriptUrl) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				if(scripts.length) {
+/******/ 					var i = scripts.length - 1;
+/******/ 					while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
+/******/ 				}
+/******/ 			}
+/******/ 		}
+/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
+/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
+/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+/******/ 		scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+/******/ 		__webpack_require__.p = scriptUrl + "../";
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/importScripts chunk loading */
+/******/ 	(() => {
+/******/ 		__webpack_require__.b = self.location + "/../../";
+/******/ 		
+/******/ 		// object to store loaded chunks
+/******/ 		// "1" means "already loaded"
+/******/ 		var installedChunks = {
+/******/ 			"WASQLiteDB": 1
+/******/ 		};
+/******/ 		
+/******/ 		// importScripts chunk loading
+/******/ 		var installChunk = (data) => {
+/******/ 			var [chunkIds, moreModules, runtime] = data;
+/******/ 			for(var moduleId in moreModules) {
+/******/ 				if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ 					__webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ 				}
+/******/ 			}
+/******/ 			if(runtime) runtime(__webpack_require__);
+/******/ 			while(chunkIds.length)
+/******/ 				installedChunks[chunkIds.pop()] = 1;
+/******/ 			parentChunkLoadingFunction(data);
+/******/ 		};
+/******/ 		__webpack_require__.f.i = (chunkId, promises) => {
+/******/ 			// "1" is the signal for "already loaded"
+/******/ 			if(!installedChunks[chunkId]) {
+/******/ 				if(true) { // all chunks have JS
+/******/ 					importScripts(__webpack_require__.p + __webpack_require__.u(chunkId));
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 		
+/******/ 		var chunkLoadingGlobal = self["webpackChunksdk_web"] = self["webpackChunksdk_web"] || [];
+/******/ 		var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);
+/******/ 		chunkLoadingGlobal.push = installChunk;
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+/*!************************************************!*\
+  !*** ./lib/src/worker/db/WASQLiteDB.worker.js ***!
+  \************************************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @journeyapps/wa-sqlite */ "../../node_modules/@journeyapps/wa-sqlite/src/sqlite-api.js");
+/* harmony import */ var comlink__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! comlink */ "../../node_modules/comlink/dist/esm/comlink.mjs");
+/* harmony import */ var _shared_open_db__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../shared/open-db */ "./lib/src/shared/open-db.js");
+/**
+ * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
+ */
+
+
+
+const DBMap = new Map();
+const OPEN_DB_LOCK = 'open-wasqlite-db';
+let nextClientId = 1;
+const openDBShared = async (dbFileName) => {
+    // Prevent multiple simultaneous opens from causing race conditions
+    return navigator.locks.request(OPEN_DB_LOCK, async () => {
+        const clientId = nextClientId++;
+        if (!DBMap.has(dbFileName)) {
+            const clientIds = new Set();
+            const connection = await (0,_shared_open_db__WEBPACK_IMPORTED_MODULE_1__._openDB)(dbFileName);
+            DBMap.set(dbFileName, {
+                clientIds,
+                db: connection
+            });
+        }
+        const dbEntry = DBMap.get(dbFileName);
+        dbEntry.clientIds.add(clientId);
+        const { db } = dbEntry;
+        const wrappedConnection = {
+            ...db,
+            close: comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(() => {
+                const { clientIds } = dbEntry;
+                clientIds.delete(clientId);
+                if (clientIds.size == 0) {
+                    console.debug(`Closing connection to ${dbFileName}.`);
+                    DBMap.delete(dbFileName);
+                    return db.close?.();
+                }
+                console.debug(`Connection to ${dbFileName} not closed yet due to active clients.`);
+            })
+        };
+        return comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(wrappedConnection);
+    });
+};
+const openDBDedicated = async (dbFileName) => {
+    const connection = await (0,_shared_open_db__WEBPACK_IMPORTED_MODULE_1__._openDB)(dbFileName);
+    return comlink__WEBPACK_IMPORTED_MODULE_2__.proxy(connection);
+};
+// Check if we're in a SharedWorker context
+if (typeof SharedWorkerGlobalScope !== 'undefined') {
+    const _self = self;
+    _self.onconnect = function (event) {
+        const port = event.ports[0];
+        console.debug('Exposing shared db on port', port);
+        comlink__WEBPACK_IMPORTED_MODULE_2__.expose(openDBShared, port);
+    };
+    addEventListener('unload', () => {
+        Array.from(DBMap.values()).forEach(async (dbConnection) => {
+            const db = await dbConnection.db;
+            db.close?.();
+        });
+    });
+}
+else {
+    comlink__WEBPACK_IMPORTED_MODULE_2__.expose(openDBDedicated);
+}
+
+sdk_web = __webpack_exports__;
+/******/ })()
+;
+//# sourceMappingURL=WASQLiteDB.umd.js.map