@rljson/io-sqlite 0.0.10 → 0.0.12

package/dist/io-sqlite.js

@@ -1,955 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { hip, hsh } from "@rljson/hash";
-import { IsReady } from "@rljson/is-ready";
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-function getAugmentedNamespace(n) {
-  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
-  var f = n.default;
-  if (typeof f == "function") {
-    var a = function a2() {
-      if (this instanceof a2) {
-        return Reflect.construct(f, arguments, this.constructor);
-      }
-      return f.apply(this, arguments);
-    };
-    a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, "__esModule", { value: true });
-  Object.keys(n).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n, k);
-    Object.defineProperty(a, k, d.get ? d : {
-      enumerable: true,
-      get: function() {
-        return n[k];
-      }
-    });
-  });
-  return a;
-}
-var lib = { exports: {} };
-function commonjsRequire(path) {
-  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-const __viteBrowserExternal = {};
-const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: __viteBrowserExternal
-}, Symbol.toStringTag, { value: "Module" }));
-const require$$1 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
-var util = {};
-var hasRequiredUtil;
-function requireUtil() {
-  if (hasRequiredUtil) return util;
-  hasRequiredUtil = 1;
-  util.getBooleanOption = (options, key) => {
-    let value = false;
-    if (key in options && typeof (value = options[key]) !== "boolean") {
-      throw new TypeError(`Expected the "${key}" option to be a boolean`);
-    }
-    return value;
-  };
-  util.cppdb = Symbol();
-  util.inspect = Symbol.for("nodejs.util.inspect.custom");
-  return util;
-}
-var sqliteError;
-var hasRequiredSqliteError;
-function requireSqliteError() {
-  if (hasRequiredSqliteError) return sqliteError;
-  hasRequiredSqliteError = 1;
-  const descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
-  function SqliteError(message, code) {
-    if (new.target !== SqliteError) {
-      return new SqliteError(message, code);
-    }
-    if (typeof code !== "string") {
-      throw new TypeError("Expected second argument to be a string");
-    }
-    Error.call(this, message);
-    descriptor.value = "" + message;
-    Object.defineProperty(this, "message", descriptor);
-    Error.captureStackTrace(this, SqliteError);
-    this.code = code;
-  }
-  Object.setPrototypeOf(SqliteError, Error);
-  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-  Object.defineProperty(SqliteError.prototype, "name", descriptor);
-  sqliteError = SqliteError;
-  return sqliteError;
-}
-var bindings = { exports: {} };
-var fileUriToPath_1;
-var hasRequiredFileUriToPath;
-function requireFileUriToPath() {
-  if (hasRequiredFileUriToPath) return fileUriToPath_1;
-  hasRequiredFileUriToPath = 1;
-  var sep = require$$1.sep || "/";
-  fileUriToPath_1 = fileUriToPath;
-  function fileUriToPath(uri) {
-    if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
-      throw new TypeError("must pass in a file:// URI to convert to a file path");
-    }
-    var rest = decodeURI(uri.substring(7));
-    var firstSlash = rest.indexOf("/");
-    var host = rest.substring(0, firstSlash);
-    var path = rest.substring(firstSlash + 1);
-    if ("localhost" == host) host = "";
-    if (host) {
-      host = sep + sep + host;
-    }
-    path = path.replace(/^(.+)\|/, "$1:");
-    if (sep == "\\") {
-      path = path.replace(/\//g, "\\");
-    }
-    if (/^.+\:/.test(path)) ;
-    else {
-      path = sep + path;
-    }
-    return host + path;
-  }
-  return fileUriToPath_1;
-}
-var hasRequiredBindings;
-function requireBindings() {
-  if (hasRequiredBindings) return bindings.exports;
-  hasRequiredBindings = 1;
-  (function(module, exports) {
-    var fs = require$$1, path = require$$1, fileURLToPath = requireFileUriToPath(), join = path.join, dirname = path.dirname, exists = fs.accessSync && function(path2) {
-      try {
-        fs.accessSync(path2);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    } || fs.existsSync || path.existsSync, defaults = {
-      arrow: process.env.NODE_BINDINGS_ARROW || " → ",
-      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
-      platform: process.platform,
-      arch: process.arch,
-      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
-      version: process.versions.node,
-      bindings: "bindings.node",
-      try: [
-        // node-gyp's linked version in the "build" dir
-        ["module_root", "build", "bindings"],
-        // node-waf and gyp_addon (a.k.a node-gyp)
-        ["module_root", "build", "Debug", "bindings"],
-        ["module_root", "build", "Release", "bindings"],
-        // Debug files, for development (legacy behavior, remove for node v0.9)
-        ["module_root", "out", "Debug", "bindings"],
-        ["module_root", "Debug", "bindings"],
-        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-        ["module_root", "out", "Release", "bindings"],
-        ["module_root", "Release", "bindings"],
-        // Legacy from node-waf, node <= 0.4.x
-        ["module_root", "build", "default", "bindings"],
-        // Production "Release" buildtype binary (meh...)
-        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
-        // node-qbs builds
-        ["module_root", "addon-build", "release", "install-root", "bindings"],
-        ["module_root", "addon-build", "debug", "install-root", "bindings"],
-        ["module_root", "addon-build", "default", "install-root", "bindings"],
-        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
-        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
-      ]
-    };
-    function bindings2(opts) {
-      if (typeof opts == "string") {
-        opts = { bindings: opts };
-      } else if (!opts) {
-        opts = {};
-      }
-      Object.keys(defaults).map(function(i2) {
-        if (!(i2 in opts)) opts[i2] = defaults[i2];
-      });
-      if (!opts.module_root) {
-        opts.module_root = exports.getRoot(exports.getFileName());
-      }
-      if (path.extname(opts.bindings) != ".node") {
-        opts.bindings += ".node";
-      }
-      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : commonjsRequire;
-      var tries = [], i = 0, l = opts.try.length, n, b, err;
-      for (; i < l; i++) {
-        n = join.apply(
-          null,
-          opts.try[i].map(function(p) {
-            return opts[p] || p;
-          })
-        );
-        tries.push(n);
-        try {
-          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-          if (!opts.path) {
-            b.path = n;
-          }
-          return b;
-        } catch (e) {
-          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
-            throw e;
-          }
-        }
-      }
-      err = new Error(
-        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
-          return opts.arrow + a;
-        }).join("\n")
-      );
-      err.tries = tries;
-      throw err;
-    }
-    module.exports = exports = bindings2;
-    exports.getFileName = function getFileName(calling_file) {
-      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
-      Error.stackTraceLimit = 10;
-      Error.prepareStackTrace = function(e, st) {
-        for (var i = 0, l = st.length; i < l; i++) {
-          fileName = st[i].getFileName();
-          if (fileName !== __filename) {
-            if (calling_file) {
-              if (fileName !== calling_file) {
-                return;
-              }
-            } else {
-              return;
-            }
-          }
-        }
-      };
-      Error.captureStackTrace(dummy);
-      dummy.stack;
-      Error.prepareStackTrace = origPST;
-      Error.stackTraceLimit = origSTL;
-      var fileSchema = "file://";
-      if (fileName.indexOf(fileSchema) === 0) {
-        fileName = fileURLToPath(fileName);
-      }
-      return fileName;
-    };
-    exports.getRoot = function getRoot(file) {
-      var dir = dirname(file), prev;
-      while (true) {
-        if (dir === ".") {
-          dir = process.cwd();
-        }
-        if (exists(join(dir, "package.json")) || exists(join(dir, "node_modules"))) {
-          return dir;
-        }
-        if (prev === dir) {
-          throw new Error(
-            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
-          );
-        }
-        prev = dir;
-        dir = join(dir, "..");
-      }
-    };
-  })(bindings, bindings.exports);
-  return bindings.exports;
-}
-var wrappers = {};
-var hasRequiredWrappers;
-function requireWrappers() {
-  if (hasRequiredWrappers) return wrappers;
-  hasRequiredWrappers = 1;
-  const { cppdb } = requireUtil();
-  wrappers.prepare = function prepare(sql) {
-    return this[cppdb].prepare(sql, this, false);
-  };
-  wrappers.exec = function exec(sql) {
-    this[cppdb].exec(sql);
-    return this;
-  };
-  wrappers.close = function close() {
-    this[cppdb].close();
-    return this;
-  };
-  wrappers.loadExtension = function loadExtension(...args) {
-    this[cppdb].loadExtension(...args);
-    return this;
-  };
-  wrappers.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-    this[cppdb].defaultSafeIntegers(...args);
-    return this;
-  };
-  wrappers.unsafeMode = function unsafeMode(...args) {
-    this[cppdb].unsafeMode(...args);
-    return this;
-  };
-  wrappers.getters = {
-    name: {
-      get: function name() {
-        return this[cppdb].name;
-      },
-      enumerable: true
-    },
-    open: {
-      get: function open() {
-        return this[cppdb].open;
-      },
-      enumerable: true
-    },
-    inTransaction: {
-      get: function inTransaction() {
-        return this[cppdb].inTransaction;
-      },
-      enumerable: true
-    },
-    readonly: {
-      get: function readonly() {
-        return this[cppdb].readonly;
-      },
-      enumerable: true
-    },
-    memory: {
-      get: function memory() {
-        return this[cppdb].memory;
-      },
-      enumerable: true
-    }
-  };
-  return wrappers;
-}
-var transaction;
-var hasRequiredTransaction;
-function requireTransaction() {
-  if (hasRequiredTransaction) return transaction;
-  hasRequiredTransaction = 1;
-  const { cppdb } = requireUtil();
-  const controllers = /* @__PURE__ */ new WeakMap();
-  transaction = function transaction2(fn) {
-    if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
-    const db = this[cppdb];
-    const controller = getController(db, this);
-    const { apply } = Function.prototype;
-    const properties = {
-      default: { value: wrapTransaction(apply, fn, db, controller.default) },
-      deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
-      immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
-      exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
-      database: { value: this, enumerable: true }
-    };
-    Object.defineProperties(properties.default.value, properties);
-    Object.defineProperties(properties.deferred.value, properties);
-    Object.defineProperties(properties.immediate.value, properties);
-    Object.defineProperties(properties.exclusive.value, properties);
-    return properties.default.value;
-  };
-  const getController = (db, self) => {
-    let controller = controllers.get(db);
-    if (!controller) {
-      const shared = {
-        commit: db.prepare("COMMIT", self, false),
-        rollback: db.prepare("ROLLBACK", self, false),
-        savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
-        release: db.prepare("RELEASE `	_bs3.	`", self, false),
-        rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
-      };
-      controllers.set(db, controller = {
-        default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
-        deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
-        immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
-        exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
-      });
-    }
-    return controller;
-  };
-  const wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
-    let before, after, undo;
-    if (db.inTransaction) {
-      before = savepoint;
-      after = release;
-      undo = rollbackTo;
-    } else {
-      before = begin;
-      after = commit;
-      undo = rollback;
-    }
-    before.run();
-    try {
-      const result = apply.call(fn, this, arguments);
-      after.run();
-      return result;
-    } catch (ex) {
-      if (db.inTransaction) {
-        undo.run();
-        if (undo !== rollback) after.run();
-      }
-      throw ex;
-    }
-  };
-  return transaction;
-}
-var pragma;
-var hasRequiredPragma;
-function requirePragma() {
-  if (hasRequiredPragma) return pragma;
-  hasRequiredPragma = 1;
-  const { getBooleanOption, cppdb } = requireUtil();
-  pragma = function pragma2(source, options) {
-    if (options == null) options = {};
-    if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
-    if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-    const simple = getBooleanOption(options, "simple");
-    const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
-    return simple ? stmt.pluck().get() : stmt.all();
-  };
-  return pragma;
-}
-var backup;
-var hasRequiredBackup;
-function requireBackup() {
-  if (hasRequiredBackup) return backup;
-  hasRequiredBackup = 1;
-  const fs = require$$1;
-  const path = require$$1;
-  const { promisify } = require$$1;
-  const { cppdb } = requireUtil();
-  const fsAccess = promisify(fs.access);
-  backup = async function backup2(filename, options) {
-    if (options == null) options = {};
-    if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
-    if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-    filename = filename.trim();
-    const attachedName = "attached" in options ? options.attached : "main";
-    const handler = "progress" in options ? options.progress : null;
-    if (!filename) throw new TypeError("Backup filename cannot be an empty string");
-    if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
-    if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
-    if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-    if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
-    await fsAccess(path.dirname(filename)).catch(() => {
-      throw new TypeError("Cannot save backup because the directory does not exist");
-    });
-    const isNewFile = await fsAccess(filename).then(() => false, () => true);
-    return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
-  };
-  const runBackup = (backup2, handler) => {
-    let rate = 0;
-    let useDefault = true;
-    return new Promise((resolve, reject) => {
-      setImmediate(function step() {
-        try {
-          const progress = backup2.transfer(rate);
-          if (!progress.remainingPages) {
-            backup2.close();
-            resolve(progress);
-            return;
-          }
-          if (useDefault) {
-            useDefault = false;
-            rate = 100;
-          }
-          if (handler) {
-            const ret = handler(progress);
-            if (ret !== void 0) {
-              if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
-              else throw new TypeError("Expected progress callback to return a number or undefined");
-            }
-          }
-          setImmediate(step);
-        } catch (err) {
-          backup2.close();
-          reject(err);
-        }
-      });
-    });
-  };
-  return backup;
-}
-var serialize;
-var hasRequiredSerialize;
-function requireSerialize() {
-  if (hasRequiredSerialize) return serialize;
-  hasRequiredSerialize = 1;
-  const { cppdb } = requireUtil();
-  serialize = function serialize2(options) {
-    if (options == null) options = {};
-    if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
-    const attachedName = "attached" in options ? options.attached : "main";
-    if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
-    if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-    return this[cppdb].serialize(attachedName);
-  };
-  return serialize;
-}
-var _function;
-var hasRequired_function;
-function require_function() {
-  if (hasRequired_function) return _function;
-  hasRequired_function = 1;
-  const { getBooleanOption, cppdb } = requireUtil();
-  _function = function defineFunction(name, options, fn) {
-    if (options == null) options = {};
-    if (typeof options === "function") {
-      fn = options;
-      options = {};
-    }
-    if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-    if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
-    if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-    if (!name) throw new TypeError("User-defined function name cannot be an empty string");
-    const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
-    const deterministic = getBooleanOption(options, "deterministic");
-    const directOnly = getBooleanOption(options, "directOnly");
-    const varargs = getBooleanOption(options, "varargs");
-    let argCount = -1;
-    if (!varargs) {
-      argCount = fn.length;
-      if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
-      if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
-    }
-    this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
-    return this;
-  };
-  return _function;
-}
-var aggregate;
-var hasRequiredAggregate;
-function requireAggregate() {
-  if (hasRequiredAggregate) return aggregate;
-  hasRequiredAggregate = 1;
-  const { getBooleanOption, cppdb } = requireUtil();
-  aggregate = function defineAggregate(name, options) {
-    if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-    if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
-    if (!name) throw new TypeError("User-defined function name cannot be an empty string");
-    const start = "start" in options ? options.start : null;
-    const step = getFunctionOption(options, "step", true);
-    const inverse = getFunctionOption(options, "inverse", false);
-    const result = getFunctionOption(options, "result", false);
-    const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
-    const deterministic = getBooleanOption(options, "deterministic");
-    const directOnly = getBooleanOption(options, "directOnly");
-    const varargs = getBooleanOption(options, "varargs");
-    let argCount = -1;
-    if (!varargs) {
-      argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
-      if (argCount > 0) argCount -= 1;
-      if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
-    }
-    this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
-    return this;
-  };
-  const getFunctionOption = (options, key, required) => {
-    const value = key in options ? options[key] : null;
-    if (typeof value === "function") return value;
-    if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
-    if (required) throw new TypeError(`Missing required option "${key}"`);
-    return null;
-  };
-  const getLength = ({ length }) => {
-    if (Number.isInteger(length) && length >= 0) return length;
-    throw new TypeError("Expected function.length to be a positive integer");
-  };
-  return aggregate;
-}
-var table;
-var hasRequiredTable;
-function requireTable() {
-  if (hasRequiredTable) return table;
-  hasRequiredTable = 1;
-  const { cppdb } = requireUtil();
-  table = function defineTable(name, factory) {
-    if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-    if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
-    let eponymous = false;
-    if (typeof factory === "object" && factory !== null) {
-      eponymous = true;
-      factory = defer(parseTableDefinition(factory, "used", name));
-    } else {
-      if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
-      factory = wrapFactory(factory);
-    }
-    this[cppdb].table(factory, name, eponymous);
-    return this;
-  };
-  function wrapFactory(factory) {
-    return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
-      const thisObject = {
-        module: moduleName,
-        database: databaseName,
-        table: tableName
-      };
-      const def = apply.call(factory, thisObject, args);
-      if (typeof def !== "object" || def === null) {
-        throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
-      }
-      return parseTableDefinition(def, "returned", moduleName);
-    };
-  }
-  function parseTableDefinition(def, verb, moduleName) {
-    if (!hasOwnProperty.call(def, "rows")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
-    }
-    if (!hasOwnProperty.call(def, "columns")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
-    }
-    const rows = def.rows;
-    if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
-    }
-    let columns = def.columns;
-    if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
-    }
-    if (columns.length !== new Set(columns).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
-    }
-    if (!columns.length) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
-    }
-    let parameters;
-    if (hasOwnProperty.call(def, "parameters")) {
-      parameters = def.parameters;
-      if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
-      }
-    } else {
-      parameters = inferParameters(rows);
-    }
-    if (parameters.length !== new Set(parameters).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
-    }
-    if (parameters.length > 32) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
-    }
-    for (const parameter of parameters) {
-      if (columns.includes(parameter)) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
-      }
-    }
-    let safeIntegers = 2;
-    if (hasOwnProperty.call(def, "safeIntegers")) {
-      const bool = def.safeIntegers;
-      if (typeof bool !== "boolean") {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
-      }
-      safeIntegers = +bool;
-    }
-    let directOnly = false;
-    if (hasOwnProperty.call(def, "directOnly")) {
-      directOnly = def.directOnly;
-      if (typeof directOnly !== "boolean") {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
-      }
-    }
-    const columnDefinitions = [
-      ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
-      ...columns.map(identifier)
-    ];
-    return [
-      `CREATE TABLE x(${columnDefinitions.join(", ")});`,
-      wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
-      parameters,
-      safeIntegers,
-      directOnly
-    ];
-  }
-  function wrapGenerator(generator, columnMap, moduleName) {
-    return function* virtualTable(...args) {
-      const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
-      for (let i = 0; i < columnMap.size; ++i) {
-        output.push(null);
-      }
-      for (const row of generator(...args)) {
-        if (Array.isArray(row)) {
-          extractRowArray(row, output, columnMap.size, moduleName);
-          yield output;
-        } else if (typeof row === "object" && row !== null) {
-          extractRowObject(row, output, columnMap, moduleName);
-          yield output;
-        } else {
-          throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
-        }
-      }
-    };
-  }
-  function extractRowArray(row, output, columnCount, moduleName) {
-    if (row.length !== columnCount) {
-      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
-    }
-    const offset = output.length - columnCount;
-    for (let i = 0; i < columnCount; ++i) {
-      output[i + offset] = row[i];
-    }
-  }
-  function extractRowObject(row, output, columnMap, moduleName) {
-    let count = 0;
-    for (const key of Object.keys(row)) {
-      const index = columnMap.get(key);
-      if (index === void 0) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
-      }
-      output[index] = row[key];
-      count += 1;
-    }
-    if (count !== columnMap.size) {
-      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
-    }
-  }
-  function inferParameters({ length }) {
-    if (!Number.isInteger(length) || length < 0) {
-      throw new TypeError("Expected function.length to be a positive integer");
-    }
-    const params = [];
-    for (let i = 0; i < length; ++i) {
-      params.push(`$${i + 1}`);
-    }
-    return params;
-  }
-  const { hasOwnProperty } = Object.prototype;
-  const { apply } = Function.prototype;
-  const GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
-  });
-  const identifier = (str) => `"${str.replace(/"/g, '""')}"`;
-  const defer = (x) => () => x;
-  return table;
-}
-var inspect;
-var hasRequiredInspect;
-function requireInspect() {
-  if (hasRequiredInspect) return inspect;
-  hasRequiredInspect = 1;
-  const DatabaseInspection = function Database2() {
-  };
-  inspect = function inspect2(depth, opts) {
-    return Object.assign(new DatabaseInspection(), this);
-  };
-  return inspect;
-}
-var database;
-var hasRequiredDatabase;
-function requireDatabase() {
-  if (hasRequiredDatabase) return database;
-  hasRequiredDatabase = 1;
-  const fs = require$$1;
-  const path = require$$1;
-  const util2 = requireUtil();
-  const SqliteError = requireSqliteError();
-  let DEFAULT_ADDON;
-  function Database2(filenameGiven, options) {
-    if (new.target == null) {
-      return new Database2(filenameGiven, options);
-    }
-    let buffer;
-    if (Buffer.isBuffer(filenameGiven)) {
-      buffer = filenameGiven;
-      filenameGiven = ":memory:";
-    }
-    if (filenameGiven == null) filenameGiven = "";
-    if (options == null) options = {};
-    if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
-    if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-    if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
-    if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
-    const filename = filenameGiven.trim();
-    const anonymous = filename === "" || filename === ":memory:";
-    const readonly = util2.getBooleanOption(options, "readonly");
-    const fileMustExist = util2.getBooleanOption(options, "fileMustExist");
-    const timeout = "timeout" in options ? options.timeout : 5e3;
-    const verbose = "verbose" in options ? options.verbose : null;
-    const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
-    if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
-    if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
-    if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
-    if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
-    if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
-    let addon;
-    if (nativeBinding == null) {
-      addon = DEFAULT_ADDON || (DEFAULT_ADDON = requireBindings()("better_sqlite3.node"));
-    } else if (typeof nativeBinding === "string") {
-      const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : commonjsRequire;
-      addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-    } else {
-      addon = nativeBinding;
-    }
-    if (!addon.isInitialized) {
-      addon.setErrorConstructor(SqliteError);
-      addon.isInitialized = true;
-    }
-    if (!anonymous && !fs.existsSync(path.dirname(filename))) {
-      throw new TypeError("Cannot open database because the directory does not exist");
-    }
-    Object.defineProperties(this, {
-      [util2.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
-      ...wrappers2.getters
-    });
-  }
-  const wrappers2 = requireWrappers();
-  Database2.prototype.prepare = wrappers2.prepare;
-  Database2.prototype.transaction = requireTransaction();
-  Database2.prototype.pragma = requirePragma();
-  Database2.prototype.backup = requireBackup();
-  Database2.prototype.serialize = requireSerialize();
-  Database2.prototype.function = require_function();
-  Database2.prototype.aggregate = requireAggregate();
-  Database2.prototype.table = requireTable();
-  Database2.prototype.loadExtension = wrappers2.loadExtension;
-  Database2.prototype.exec = wrappers2.exec;
-  Database2.prototype.close = wrappers2.close;
-  Database2.prototype.defaultSafeIntegers = wrappers2.defaultSafeIntegers;
-  Database2.prototype.unsafeMode = wrappers2.unsafeMode;
-  Database2.prototype[util2.inspect] = requireInspect();
-  database = Database2;
-  return database;
-}
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib.exports;
-  hasRequiredLib = 1;
-  lib.exports = requireDatabase();
-  lib.exports.SqliteError = requireSqliteError();
-  return lib.exports;
-}
-var libExports = requireLib();
-const Database = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
-// @license
-class IoSqlite {
-  // ...........................................................................
-  // Constructor & example
-  constructor(dbPath) {
-    __publicField(this, "_db");
-    __publicField(this, "_dbPath");
-    // ######################
-    // Private
-    // ######################
-    __publicField(this, "_isReady", new IsReady());
-    // ...........................................................................
-    __publicField(this, "_initTableCfgs", () => {
-      const tableCfg = {
-        version: 1,
-        key: "tableCfgs",
-        type: "ingredients",
-        columns: {
-          key: { key: "key", type: "string", previous: "string" },
-          type: { key: "type", type: "string", previous: "string" }
-        }
-      };
-      hip(tableCfg);
-      const tableCfgHashed = hsh(tableCfg);
-      try {
-        this._db.prepare(
-          `
-      CREATE TABLE IF NOT EXISTS tableCfgs (
-        _hash TEXT PRIMARY KEY,
-        version INTEGER,
-        key TEXT KEY,
-        type TEXT,
-        previous TEXT
-      );
-    `
-        ).run();
-      } catch (error) {
-        console.error(error);
-      }
-      this._db.prepare(
-        `
-      INSERT INTO tableCfgs (_hash, version, key, type) VALUES (?, ?, ?, ?);
-    `
-      ).run(tableCfgHashed._hash, tableCfg.version, tableCfg.key, tableCfg.type);
-    });
-    this.dbPath = dbPath;
-    this._dbPath = dbPath;
-    this._db = new Database(dbPath);
-    this._init();
-  }
-  async deleteDatabase() {
-    this._db.close();
-    delete this._dbPath;
-  }
-  // ...........................................................................
-  // General
-  isReady() {
-    return this._isReady.promise;
-  }
-  // ...........................................................................
-  // Dump (export all data from database)
-  dump() {
-    return this._dump();
-  }
-  dumpTable(request) {
-    return this._dumpTable(request);
-  }
-  // ...........................................................................
-  // Rows
-  readRow(request) {
-    return this._readRow(request);
-  }
-  readRows(request) {
-    return this._readRows(request);
-  }
-  // ...........................................................................
-  // Write
-  write(request) {
-    return this._write(request);
-  }
-  // ...........................................................................
-  // Table management
-  createTable(request) {
-    return this._createTable(request);
-  }
-  async tables() {
-    return this._tables();
-  }
-  // ...........................................................................
-  async _init() {
-    this._initTableCfgs();
-    this._isReady.resolve();
-  }
-  // ...........................................................................
-  async _createTable(request) {
-    const config = {};
-    if (!config) {
-      throw new Error(`Table config ${request.tableCfg} not found`);
-    }
-    console.log(request.tableCfg);
-  }
-  // ...........................................................................
-  async _tables() {
-    throw new Error("Not implemented");
-  }
-  // ...........................................................................
-  async _readRow(request) {
-    throw new Error("Not implemented " + request);
-  }
-  // ...........................................................................
-  async _readRows(request) {
-    throw new Error("Not implemented " + request);
-  }
-  // ...........................................................................
-  async _dump() {
-    const tablesQuery = `
-      SELECT name
-      FROM sqlite_master
-      WHERE type='table' AND name NOT LIKE 'sqlite_%';
-    `;
-    const returnFile = {};
-    const tables = this._db.prepare(tablesQuery).all();
-    for (const table2 of tables) {
-      const tableDump = await this._dumpTable({ table: table2.name });
-      const tableDumpJson = JSON.parse(JSON.stringify(tableDump));
-      returnFile[table2.name] = tableDumpJson;
-    }
-    return returnFile;
-  }
-  // ...........................................................................
-  async _dumpTable(request) {
-    const query = `SELECT * FROM ${request.table}`;
-    let returnFile = {};
-    const returnValue = this._db.prepare(query).all();
-    returnFile = JSON.parse(JSON.stringify(returnValue));
-    return returnFile;
-  }
-  // ...........................................................................
-  async _write(request) {
-    throw new Error("Not implemented " + request);
-  }
-}
-export {
-  IoSqlite
-};