ueberdb2 5.0.39 → 5.0.41

package/dist/index.js

@@ -3,2260 +3,10 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let util = require("util");
-util = __toESM(util);
-let cassandra_driver = require("cassandra-driver");
-let http = require("http");
-http = __toESM(http);
-let nano = require("nano");
-nano = __toESM(nano);
-let dirty_ts = require("dirty-ts");
-dirty_ts = __toESM(dirty_ts);
-let node_path = require("node:path");
-let simple_git = require("simple-git");
-let assert = require("assert");
-assert = __toESM(assert);
-let buffer = require("buffer");
-let crypto = require("crypto");
-let _elastic_elasticsearch = require("@elastic/elasticsearch");
-let events = require("events");
-events = __toESM(events);
-let mongodb = require("mongodb");
-let async = require("async");
-async = __toESM(async);
-let mssql = require("mssql");
-mssql = __toESM(mssql);
-let mysql2 = require("mysql2");
-let pg = require("pg");
-pg = __toESM(pg);
-let redis = require("redis");
-let rethinkdb = require("rethinkdb");
-rethinkdb = __toESM(rethinkdb);
-let rusty_store_kv = require("rusty-store-kv");
-let surrealdb = require("surrealdb");
-//#region lib/CacheAndBufferLayer.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-/**
-* This module is made for the case, you want to use a SQL-Based Databse or a KeyValue Database that
-* can only save strings(and no objects), as a JSON KeyValue Store.
-*
-* The idea of the dbWrapper is to provide following features:
-*
-*   * automatic JSON serialize/deserialize to abstract that away from the database driver and the
-*     module user.
-*   * cache reads. A amount of KeyValues are hold in the memory, so that reading is faster.
-*   * Buffer DB Writings. Sets and deletes should be buffered to make them in a setted interval
-*     with a bulk. This reduces the overhead of database transactions and makes the database
-*     faster. But there is also a danger to loose data integrity, to keep that, we should provide a
-*     flush function.
-*
-* All Features can be disabled or configured. The Wrapper provides default settings that can be
-* overwriden by the driver and by the module user.
-*/
-/**
-* Cache with Least Recently Used eviction policy.
-*/
-var LRU = class {
-	/**
-	* @param evictable Optional predicate that dictates whether it is permissable to evict the entry
-	*     if it is old and the cache is over capacity. The predicate is passed two arguments (key,
-	*     value). If no predicate is provided, all entries are evictable. Warning: Non-evictable
-	*     entries can cause the cache to go over capacity. If the number of non-evictable entries is
-	*     greater than or equal to the capacity, all new evictable entries will be evicted
-	*     immediately.
-	*/
-	constructor(capacity, evictable = (k, v) => true) {
-		this._capacity = capacity;
-		this._evictable = evictable;
-		this._cache = /* @__PURE__ */ new Map();
-	}
-	/**
-	* The entries accessed via this iterator are not considered to have been "used" (for purposes of
-	* determining least recently used).
-	*/
-	[Symbol.iterator]() {
-		return this._cache.entries();
-	}
-	/**
-	* @param isUse Optional boolean indicating whether this get() should be considered a "use" of the
-	*     entry (for determining least recently used). Defaults to true.
-	* @returns undefined if there is no entry matching the given key.
-	*/
-	get(k, isUse = true) {
-		if (!this._cache.has(k)) return;
-		const v = this._cache.get(k);
-		if (isUse) {
-			this._cache.delete(k);
-			this._cache.set(k, v);
-		}
-		return v;
-	}
-	/**
-	* Adds or updates an entry in the cache. This marks the entry as the most recently used entry.
-	*/
-	set(k, v) {
-		this._cache.delete(k);
-		this._cache.set(k, v);
-		this.evictOld();
-	}
-	/**
-	* Evicts the oldest evictable entries until the number of entries is equal to or less than the
-	* cache's capacity. This method is automatically called by set(). Call this if you need to evict
-	* newly evictable entries before the next call to set().
-	*/
-	evictOld() {
-		for (const [k, v] of this._cache.entries()) {
-			if (this._cache.size <= this._capacity) break;
-			if (!this._evictable(k, v)) continue;
-			this._cache.delete(k);
-		}
-	}
-};
-var SelfContainedPromise = class extends Promise {
-	constructor(executor = null) {
-		let done;
-		super((resolve, reject) => {
-			done = (err, val) => err != null ? reject(err) : resolve(val);
-			if (executor != null) executor(resolve, reject);
-		});
-		this.done = done;
-	}
-};
-const defaultSettings = {
-	bulkLimit: 0,
-	cache: 1e4,
-	writeInterval: 100,
-	json: true,
-	charset: "utf8mb4"
-};
-const Database$1 = class {
-	/**
-	* @param wrappedDB The Database that should be wrapped
-	* @param settings (optional) The settings that should be applied to the wrapper
-	*/
-	constructor(wrappedDB, settings, logger) {
-		if (wrappedDB.isAsync) this.wrappedDB = wrappedDB;
-		else {
-			this.wrappedDB = {};
-			for (const fn of [
-				"close",
-				"doBulk",
-				"findKeys",
-				"get",
-				"init",
-				"remove",
-				"set"
-			]) {
-				const f = wrappedDB[fn];
-				if (typeof f !== "function") continue;
-				this.wrappedDB[fn] = util.default.promisify(f.bind(wrappedDB));
-			}
-		}
-		this.logger = logger;
-		this.settings = Object.freeze({
-			...defaultSettings,
-			...wrappedDB.settings || {},
-			...settings || {}
-		});
-		this.buffer = new LRU(this.settings.cache, (k, v) => !v.dirty && !v.writingInProgress);
-		this._flushPaused = null;
-		this._locks = /* @__PURE__ */ new Map();
-		this.metrics = {
-			lockAwaits: 0,
-			lockAcquires: 0,
-			lockReleases: 0,
-			reads: 0,
-			readsFailed: 0,
-			readsFinished: 0,
-			readsFromCache: 0,
-			readsFromDb: 0,
-			readsFromDbFailed: 0,
-			readsFromDbFinished: 0,
-			writes: 0,
-			writesFailed: 0,
-			writesFinished: 0,
-			writesObsoleted: 0,
-			writesToDb: 0,
-			writesToDbFailed: 0,
-			writesToDbFinished: 0,
-			writesToDbRetried: 0
-		};
-		this.flushInterval = this.settings.writeInterval > 0 ? setInterval(() => this.flush(), this.settings.writeInterval) : null;
-	}
-	async _lock(key) {
-		while (true) {
-			const l = this._locks.get(key);
-			if (l == null) break;
-			++this.metrics.lockAwaits;
-			await l;
-		}
-		++this.metrics.lockAcquires;
-		this._locks.set(key, new SelfContainedPromise());
-	}
-	async _unlock(key) {
-		++this.metrics.lockReleases;
-		this._locks.get(key).done();
-		this._locks.delete(key);
-	}
-	_pauseFlush() {
-		if (this._flushPaused == null) {
-			this._flushPaused = new SelfContainedPromise();
-			this._flushPaused.count = 0;
-		}
-		++this._flushPaused.count;
-	}
-	_resumeFlush() {
-		if (--this._flushPaused.count > 0) return;
-		this._flushPaused.done();
-		this._flushPaused = null;
-	}
-	/**
-	* wraps the init function of the original DB
-	*/
-	async init() {
-		await this.wrappedDB.init();
-	}
-	/**
-	* wraps the close function of the original DB
-	*/
-	async close() {
-		clearInterval(this.flushInterval);
-		await this.flush();
-		await this.wrappedDB.close();
-		this.wrappedDB = null;
-	}
-	/**
-	* Gets the value trough the wrapper.
-	*/
-	async get(key) {
-		let v;
-		await this._lock(key);
-		try {
-			v = await this._getLocked(key);
-		} finally {
-			this._unlock(key);
-		}
-		return clone(v);
-	}
-	async _getLocked(key) {
-		++this.metrics.reads;
-		try {
-			const entry = this.buffer.get(key);
-			if (entry != null) {
-				++this.metrics.readsFromCache;
-				if (this.logger.isDebugEnabled()) this.logger.debug(`GET    - ${key} - ${JSON.stringify(entry.value)} - from ${entry.dirty ? "dirty buffer" : "cache"}`);
-				return entry.value;
-			}
-			let value;
-			++this.metrics.readsFromDb;
-			try {
-				value = await this.wrappedDB.get(key);
-			} catch (err) {
-				++this.metrics.readsFromDbFailed;
-				throw err;
-			} finally {
-				++this.metrics.readsFromDbFinished;
-			}
-			if (this.settings.json) try {
-				value = JSON.parse(value);
-			} catch (err) {
-				this.logger.error(`JSON-PROBLEM:${value}`);
-				throw err;
-			}
-			if (this.settings.cache > 0) this.buffer.set(key, {
-				value,
-				dirty: null,
-				writingInProgress: false
-			});
-			if (this.logger.isDebugEnabled()) this.logger.debug(`GET    - ${key} - ${JSON.stringify(value)} - from database `);
-			return value;
-		} catch (err) {
-			++this.metrics.readsFailed;
-			throw err;
-		} finally {
-			++this.metrics.readsFinished;
-		}
-	}
-	/**
-	* Find keys function searches the db sets for matching entries and
-	* returns the key entries via callback.
-	*/
-	async findKeys(key, notKey) {
-		await this.flush();
-		const keyValues = await this.wrappedDB.findKeys(key, notKey);
-		if (this.logger.isDebugEnabled()) this.logger.debug(`GET    - ${key}-${notKey} - ${JSON.stringify(keyValues)} - from database `);
-		return clone(keyValues);
-	}
-	/**
-	* Remove a record from the database
-	*/
-	async remove(key) {
-		if (this.logger.isDebugEnabled()) this.logger.debug(`DELETE - ${key} - from database `);
-		await this.set(key, null);
-	}
-	/**
-	* Sets the value trough the wrapper
-	*/
-	async set(key, value) {
-		value = clone(value);
-		let p;
-		this._pauseFlush();
-		try {
-			await this._lock(key);
-			try {
-				p = this._setLocked(key, value);
-			} finally {
-				this._unlock(key);
-			}
-		} finally {
-			this._resumeFlush();
-		}
-		await p;
-	}
-	async _setLocked(key, value) {
-		++this.metrics.writes;
-		try {
-			let entry = this.buffer.get(key);
-			if (!entry || entry.writingInProgress) entry = {};
-			else if (entry.dirty) ++this.metrics.writesObsoleted;
-			entry.value = value;
-			if (!entry.dirty) entry.dirty = new SelfContainedPromise();
-			this.buffer.set(key, entry);
-			const buffered = this.settings.writeInterval > 0;
-			if (this.logger.isDebugEnabled()) this.logger.debug(`SET    - ${key} - ${JSON.stringify(value)} - to ${buffered ? "buffer" : "database"}`);
-			if (!buffered) this._write([[key, entry]]);
-			await entry.dirty;
-		} catch (err) {
-			++this.metrics.writesFailed;
-			throw err;
-		} finally {
-			++this.metrics.writesFinished;
-		}
-	}
-	/**
-	* Sets a subvalue
-	*/
-	async setSub(key, sub, value) {
-		value = clone(value);
-		if (this.logger.isDebugEnabled()) this.logger.debug(`SETSUB - ${key}${JSON.stringify(sub)} - ${JSON.stringify(value)}`);
-		let p;
-		this._pauseFlush();
-		try {
-			await this._lock(key);
-			try {
-				let base;
-				try {
-					const fullValue = await this._getLocked(key);
-					base = { fullValue };
-					const ptr = {
-						obj: base,
-						prop: "fullValue"
-					};
-					for (let i = 0; i < sub.length; i++) {
-						if (sub[i] === "__proto__") throw new Error("Modifying object prototype is not supported for security reasons");
-						let o = ptr.obj[ptr.prop];
-						if (o == null) ptr.obj[ptr.prop] = o = {};
-						if (typeof o !== "object") throw new TypeError(`Cannot set property ${JSON.stringify(sub[i])} on non-object ${JSON.stringify(o)} (key: ${JSON.stringify(key)} value in db: ${JSON.stringify(fullValue)} sub: ${JSON.stringify(sub.slice(0, i + 1))})`);
-						ptr.obj = ptr.obj[ptr.prop];
-						ptr.prop = sub[i];
-					}
-					if (value == null) delete ptr.obj[ptr.prop];
-					else ptr.obj[ptr.prop] = value;
-				} catch (err) {
-					++this.metrics.writes;
-					++this.metrics.writesFailed;
-					++this.metrics.writesFinished;
-					throw err;
-				}
-				p = this._setLocked(key, base.fullValue);
-			} finally {
-				await this._unlock(key);
-			}
-		} finally {
-			this._resumeFlush();
-		}
-		await p;
-	}
-	/**
-	* Returns a sub value of the object
-	* @param sub is a array, for example if you want to access object.test.bla, the array is ["test",
-	*     "bla"]
-	*/
-	async getSub(key, sub) {
-		await this._lock(key);
-		try {
-			let v = await this._getLocked(key);
-			for (const k of sub) {
-				if (typeof v !== "object" || v != null && !Object.prototype.hasOwnProperty.call(v, k) || k === "__proto__") v = null;
-				if (v == null) break;
-				v = v[k];
-			}
-			if (this.logger.isDebugEnabled()) this.logger.debug(`GETSUB - ${key}${JSON.stringify(sub)} - ${JSON.stringify(v)}`);
-			return clone(v);
-		} finally {
-			this._unlock(key);
-		}
-	}
-	/**
-	* Writes all dirty values to the database
-	*/
-	async flush() {
-		if (this._flushDone == null) this._flushDone = (async () => {
-			while (true) {
-				while (this._flushPaused != null) await this._flushPaused;
-				const dirtyEntries = [];
-				for (const entry of this.buffer) if (entry[1].dirty && !entry[1].writingInProgress) {
-					dirtyEntries.push(entry);
-					if (this.settings.bulkLimit && dirtyEntries.length >= this.settings.bulkLimit) break;
-				}
-				if (dirtyEntries.length === 0) return;
-				await this._write(dirtyEntries);
-			}
-		})();
-		await this._flushDone;
-		this._flushDone = null;
-	}
-	async _write(dirtyEntries) {
-		const markDone = (entry, err) => {
-			if (entry.writingInProgress) {
-				entry.writingInProgress = false;
-				if (err != null) ++this.metrics.writesToDbFailed;
-				++this.metrics.writesToDbFinished;
-			}
-			entry.dirty.done(err);
-			entry.dirty = null;
-		};
-		const ops = [];
-		const entries = [];
-		for (const [key, entry] of dirtyEntries) {
-			let value = entry.value;
-			try {
-				value = this.settings.json && value != null ? JSON.stringify(value) : clone(value);
-			} catch (err) {
-				markDone(entry, err);
-				continue;
-			}
-			entry.writingInProgress = true;
-			ops.push({
-				type: value == null ? "remove" : "set",
-				key,
-				value
-			});
-			entries.push(entry);
-		}
-		if (ops.length === 0) return;
-		this.metrics.writesToDb += ops.length;
-		const writeOneOp = async (op, entry) => {
-			let writeErr = null;
-			try {
-				switch (op.type) {
-					case "remove":
-						await this.wrappedDB.remove(op.key);
-						break;
-					case "set":
-						await this.wrappedDB.set(op.key, op.value);
-						break;
-					default: throw new Error(`unsupported operation type: ${op.type}`);
-				}
-			} catch (err) {
-				writeErr = err || new Error(err);
-			}
-			markDone(entry, writeErr);
-		};
-		if (ops.length === 1) await writeOneOp(ops[0], entries[0]);
-		else {
-			let success = false;
-			try {
-				await this.wrappedDB.doBulk(ops);
-				success = true;
-			} catch (err) {
-				this.logger.error(`Bulk write of ${ops.length} ops failed, retrying individually: ${err.stack || err}`);
-				this.metrics.writesToDbRetried += ops.length;
-				await Promise.all(ops.map(async (op, i) => await writeOneOp(op, entries[i])));
-			}
-			if (success) entries.forEach((entry) => markDone(entry, null));
-		}
-		this.buffer.evictOld();
-	}
-};
-const clone = (obj, key = "") => {
-	if (null == obj || "object" !== typeof obj) return obj;
-	if (typeof obj.toJSON === "function") return clone(obj.toJSON(key));
-	if (obj instanceof Date) {
-		const copy = /* @__PURE__ */ new Date();
-		copy.setTime(obj.getTime());
-		return copy;
-	}
-	if (obj instanceof Array) {
-		const copy = [];
-		for (let i = 0, len = obj.length; i < len; ++i) copy[i] = clone(obj[i], String(i));
-		return copy;
-	}
-	if (obj instanceof Object) {
-		const copy = {};
-		for (const attr in obj) if (Object.prototype.hasOwnProperty.call(obj, attr)) copy[attr] = clone(obj[attr], attr);
-		return copy;
-	}
-	throw new Error("Unable to copy obj! Its type isn't supported.");
-};
-//#endregion
-//#region lib/logging.ts
-const normalizeLogger = (logger) => {
-	const logLevelsUsed = [
-		"debug",
-		"info",
-		"warn",
-		"error"
-	];
-	logger = Object.create(logger || {});
-	for (const level of logLevelsUsed) {
-		const enabledFnName = `is${level.charAt(0).toUpperCase() + level.slice(1)}Enabled`;
-		if (typeof logger[level] !== "function") {
-			logger[level] = () => {};
-			logger[enabledFnName] = () => false;
-		} else if (typeof logger[enabledFnName] !== "function") logger[enabledFnName] = () => true;
-	}
-	return logger;
-};
-//#endregion
-//#region lib/AbstractDatabase.ts
-const nullLogger = normalizeLogger(null);
-const simpleGlobToRegExp = (s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-var AbstractDatabase = class {
-	logger;
-	settings;
-	constructor(settings) {
-		if (new.target === module.exports) throw new TypeError("cannot instantiate Abstract Database directly");
-		for (const fn of [
-			"init",
-			"close",
-			"get",
-			"findKeys",
-			"remove",
-			"set"
-		]) if (typeof this[fn] !== "function") throw new TypeError(`method ${fn} not defined`);
-		this.logger = nullLogger;
-		this.settings = settings;
-	}
-	/**
-	* For findKey regex. Used by document dbs like mongodb or dirty.
-	*/
-	createFindRegex(key, notKey) {
-		let regex = `^(?=${simpleGlobToRegExp(key)}$)`;
-		if (notKey != null) regex += `(?!${simpleGlobToRegExp(notKey)}$)`;
-		return new RegExp(regex);
-	}
-	doBulk(operations, cb) {
-		throw new Error("the doBulk method must be implemented if write caching is enabled");
-	}
-	get isAsync() {
-		return false;
-	}
-};
-//#endregion
-//#region databases/cassandra_db.ts
-/**
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*    http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var Cassandra_db = class extends AbstractDatabase {
-	client;
-	pool;
-	/**
-	* @param {Object} settings The required settings object to initiate the Cassandra database
-	* @param {String[]} settings.clientOptions See
-	*     http://www.datastax.com/drivers/nodejs/2.0/global.html#ClientOptions for a full set of
-	*     options that can be used
-	* @param {String} settings.columnFamily The column family that should be used to store data. The
-	*     column family will be created if it doesn't exist
-	* @param {Function} [settings.logger] Function that will be used to pass on log events emitted by
-	*     the Cassandra driver. See https://github.com/datastax/nodejs-driver#logging for more
-	*     information
-	*/
-	constructor(settings) {
-		super(settings);
-		if (!settings.clientOptions) throw new Error("The Cassandra client options should be defined");
-		if (!settings.columnFamily) throw new Error("The Cassandra column family should be defined");
-		this.settings = { database: settings.database };
-		this.settings.clientOptions = settings.clientOptions;
-		this.settings.columnFamily = settings.columnFamily;
-		this.settings.logger = settings.logger;
-	}
-	/**
-	* Initializes the Cassandra client, connects to Cassandra and creates the CF if it didn't exist
-	* already
-	*
-	* @param  {Function}   callback        Standard callback method.
-	* @param  {Error}      callback.err    An error object (if any.)
-	*/
-	init(callback) {
-		this.client = new cassandra_driver.Client(this.settings.clientOptions);
-		if (this.settings.logger) this.client.on("log", this.settings.logger);
-		this.client.execute("SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?", [this.settings.clientOptions.keyspace], (err, result) => {
-			if (err) return callback(err);
-			let isDefined = false;
-			const length = result.rows.length;
-			for (let i = 0; i < length; i++) if (result.rows[i].columnfamily_name === this.settings.columnFamily) {
-				isDefined = true;
-				break;
-			}
-			if (isDefined) return callback(null);
-			else {
-				const cql = `CREATE COLUMNFAMILY "${this.settings.columnFamily}" (key text PRIMARY KEY, data text)`;
-				this.client && this.client.execute(cql, callback);
-			}
-		});
-	}
-	/**
-	* Gets a value from Cassandra
-	*
-	* @param  {String}     key               The key for which the value should be retrieved
-	* @param  {Function}   callback          Standard callback method
-	* @param  {Error}      callback.err      An error object, if any
-	* @param  {String}     callback.value    The value for the given key (if any)
-	*/
-	get(key, callback) {
-		const cql = `SELECT data FROM "${this.settings.columnFamily}" WHERE key = ?`;
-		this.client && this.client.execute(cql, [key], (err, result) => {
-			if (err) return callback(err);
-			if (!result.rows || result.rows.length === 0) return callback(null, null);
-			return callback(null, result.rows[0].data);
-		});
-	}
-	/**
-	* Cassandra has no native `findKeys` method. This function implements a naive filter by
-	* retrieving *all* the keys and filtering those. This should obviously be used with the utmost
-	* care and is probably not something you want to run in production.
-	*
-	* @param  {String}     key               The filter for keys that should match
-	* @param  {String}     [notKey]          The filter for keys that shouldn't match
-	* @param  {Function}   callback          Standard callback method
-	* @param  {Error}      callback.err      An error object, if any
-	* @param  {String[]}   callback.keys     An array of keys that match the specified filters
-	*/
-	findKeys(key, notKey, callback) {
-		let cql = null;
-		if (!notKey) {
-			cql = `SELECT key FROM "${this.settings.columnFamily}"`;
-			this.client && this.client.execute(cql, (err, result) => {
-				if (err) return callback(err);
-				const regex = new RegExp(`^${key.replace(/\*/g, ".*")}$`);
-				const keys = [];
-				result.rows.forEach((row) => {
-					if (regex.test(row.key)) keys.push(row.key);
-				});
-				return callback(null, keys);
-			});
-		} else if (notKey === "*:*:*") {
-			const matches = /^([^:]+):\*$/.exec(key);
-			if (matches) {
-				cql = `SELECT * from "${this.settings.columnFamily}" WHERE key = ?`;
-				this.client && this.client.execute(cql, [`ueberdb:keys:${matches[1]}`], (err, result) => {
-					if (err) return callback(err);
-					if (!result.rows || result.rows.length === 0) return callback(null, []);
-					return callback(null, result.rows.map((row) => row.data));
-				});
-			} else return callback(/* @__PURE__ */ new Error("Cassandra db only supports key patterns like pad:* when notKey is set to *:*:*"), null);
-		} else return callback(/* @__PURE__ */ new Error("Cassandra db currently only supports *:*:* as notKey"), null);
-	}
-	/**
-	* Sets a value for a key
-	*
-	* @param  {String}     key             The key to set
-	* @param  {String}     value           The value associated to this key
-	* @param  {Function}   callback        Standard callback method
-	* @param  {Error}      callback.err    An error object, if any
-	*/
-	set(key, value, callback) {
-		this.doBulk([{
-			type: "set",
-			key,
-			value
-		}], callback);
-	}
-	/**
-	* Removes a key and it's value from the column family
-	*
-	* @param  {String}     key             The key to remove
-	* @param  {Function}   callback        Standard callback method
-	* @param  {Error}      callback.err    An error object, if any
-	*/
-	remove(key, callback) {
-		this.doBulk([{
-			type: "remove",
-			key
-		}], callback);
-	}
-	/**
-	* Performs multiple operations in one action
-	*
-	* @param  {Object[]}   bulk            The set of operations that should be performed
-	* @param  {Function}   callback        Standard callback method
-	* @param  {Error}      callback.err    An error object, if any
-	*/
-	doBulk(bulk, callback) {
-		const queries = [];
-		bulk.forEach((operation) => {
-			const matches = /^([^:]+):([^:]+)$/.exec(operation.key);
-			if (operation.type === "set") {
-				queries.push({
-					query: `UPDATE "${this.settings.columnFamily}" SET data = ? WHERE key = ?`,
-					params: [operation.value, operation.key]
-				});
-				if (matches) queries.push({
-					query: `UPDATE "${this.settings.columnFamily}" SET data = ? WHERE key = ?`,
-					params: ["1", `ueberdb:keys:${matches[1]}`]
-				});
-			} else if (operation.type === "remove") {
-				queries.push({
-					query: `DELETE FROM "${this.settings.columnFamily}" WHERE key=?`,
-					params: [operation.key]
-				});
-				if (matches) queries.push({
-					query: `DELETE FROM "${this.settings.columnFamily}" WHERE key = ?`,
-					params: [`ueberdb:keys:${matches[1]}`]
-				});
-			}
-		});
-		this.client && this.client.batch(queries, { prepare: true }, callback);
-	}
-	/**
-	* Closes the Cassandra connection
-	*
-	* @param  {Function}   callback        Standard callback method
-	* @param  {Error}      callback.err    Error object in case something goes wrong
-	*/
-	close(callback) {
-		this.pool.shutdown(callback);
-	}
-};
-//#endregion
-//#region databases/couch_db.ts
-/**
-* 2012 Max 'Azul' Wiehle
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var Couch_db = class extends AbstractDatabase {
-	agent;
-	db;
-	constructor(settings) {
-		super(settings);
-		this.agent = null;
-		this.db = null;
-		this.settings = settings;
-		this.settings.cache = 1e3;
-		this.settings.writeInterval = 100;
-		this.settings.json = false;
-	}
-	get isAsync() {
-		return true;
-	}
-	async init() {
-		this.agent = new http.default.Agent({
-			keepAlive: true,
-			maxSockets: this.settings.maxListeners || 1
-		});
-		const client = (0, nano.default)({
-			url: `http://${this.settings.host}:${this.settings.port}`,
-			requestDefaults: { agent: this.agent }
-		});
-		if (this.settings.user && this.settings.password) await client.auth(this.settings.user, this.settings.password);
-		try {
-			await client.db.get(this.settings.database);
-		} catch (err) {
-			if (err.statusCode !== 404) throw err;
-			await client.db.create(this.settings.database);
-		}
-		this.db = client.use(this.settings.database);
-	}
-	async get(key) {
-		let doc;
-		try {
-			if (this.db) doc = await this.db.get(key);
-		} catch (err) {
-			if (err.statusCode === 404) return null;
-			throw err;
-		}
-		if (doc && "value" in doc) return doc.value;
-		return "";
-	}
-	async findKeys(key, notKey) {
-		const pfxLen = key.indexOf("*");
-		if (!this.db) return;
-		const pfx = pfxLen < 0 ? key : key.slice(0, pfxLen);
-		return (await this.db.find({
-			selector: { _id: pfxLen < 0 ? pfx : {
-				$gte: pfx,
-				$lte: `${pfx}\ufff0`,
-				$regex: this.createFindRegex(key, notKey).source
-			} },
-			fields: ["_id"]
-		})).docs.map((doc) => doc._id);
-	}
-	async set(key, value) {
-		let doc;
-		if (!this.db) return;
-		try {
-			doc = await this.db.get(key);
-		} catch (err) {
-			if (err.statusCode !== 404) throw err;
-		}
-		await this.db.insert({
-			_id: key,
-			value,
-			...doc == null ? {} : { _rev: doc._rev }
-		});
-	}
-	async remove(key) {
-		let header;
-		if (!this.db) return;
-		try {
-			header = await this.db.head(key);
-		} catch (err) {
-			if (err.statusCode === 404) return;
-			throw err;
-		}
-		const etag = JSON.parse(header.etag);
-		await this.db.destroy(key, etag);
-	}
-	async doBulk(bulk) {
-		if (!this.db) return;
-		const keys = bulk.map((op) => op.key);
-		const revs = {};
-		for (const { key, value } of (await this.db.fetchRevs({ keys })).rows) if (value != null) revs[key] = value.rev;
-		const setters = [];
-		for (const item of bulk) {
-			const set = {
-				_id: item.key,
-				_rev: void 0,
-				_deleted: false,
-				value: ""
-			};
-			if (revs[item.key] != null) set._rev = revs[item.key];
-			if (item.type === "set") set.value = item.value;
-			if (item.type === "remove") set._deleted = true;
-			setters.push(set);
-		}
-		await this.db.bulk({ docs: setters });
-	}
-	async close() {
-		this.db = null;
-		if (this.agent) this.agent.destroy();
-		this.agent = null;
-	}
-};
-//#endregion
-//#region databases/dirty_db.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var dirty_db_default = class extends AbstractDatabase {
-	db;
-	constructor(settings) {
-		super(settings);
-		this.db = null;
-		if (!settings || !settings.filename) settings = { filename: null };
-		this.settings = settings;
-		this.settings.cache = 0;
-		this.settings.writeInterval = 0;
-		this.settings.json = false;
-	}
-	init(callback) {
-		this.db = new dirty_ts.default(this.settings.filename);
-		this.db.on("load", () => {
-			callback();
-		});
-	}
-	get(key, callback) {
-		callback(null, this.db.get(key));
-	}
-	findKeys(key, notKey, callback) {
-		const keys = [];
-		const regex = this.createFindRegex(key, notKey);
-		this.db.forEach((key) => {
-			if (key.search(regex) !== -1) keys.push(key);
-		});
-		callback(null, keys);
-	}
-	set(key, value, callback) {
-		this.db.set(key, value, callback);
-	}
-	remove(key, callback) {
-		this.db.rm(key, callback);
-	}
-	close(callback) {
-		this.db.close();
-		this.db = null;
-		if (callback) callback();
-	}
-};
-//#endregion
-//#region databases/dirty_git_db.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var dirty_git_db_default = class extends AbstractDatabase {
-	db;
-	constructor(settings) {
-		super(settings);
-		this.db = null;
-		if (!settings || !settings.filename) settings = {};
-		this.settings = settings;
-		this.settings.cache = 0;
-		this.settings.writeInterval = 0;
-		this.settings.json = false;
-	}
-	init(callback) {
-		this.db = new dirty_ts.default(this.settings.filename);
-		this.db.on("load", (err) => {
-			callback();
-		});
-	}
-	get(key, callback) {
-		callback(null, this.db.get(key));
-	}
-	findKeys(key, notKey, callback) {
-		const keys = [];
-		const regex = this.createFindRegex(key, notKey);
-		this.db.forEach((key, val) => {
-			if (key.search(regex) !== -1) keys.push(key);
-		});
-		callback(null, keys);
-	}
-	set(key, value, callback) {
-		this.db.set(key, value, callback);
-		(0, simple_git.simpleGit)((0, node_path.dirname)(this.settings.filename)).silent(true).add("./*.db").commit("Automated commit...").push([
-			"-u",
-			"origin",
-			"master"
-		], () => console.debug("Stored git commit"));
-	}
-	remove(key, callback) {
-		this.db.rm(key, callback);
-	}
-	close(callback) {
-		this.db.close();
-		if (callback) callback();
-	}
-};
-//#endregion
-//#region databases/elasticsearch_db.ts
-/**
-* 2015 Visionist, Inc.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-const schema = "2";
-const keyToId = (key) => {
-	const keyBuf = buffer.Buffer.from(key);
-	return keyBuf.length > 512 ? (0, crypto.createHash)("sha512").update(keyBuf).digest("hex") : key;
-};
-const mappings = { properties: {
-	key: { type: "wildcard" },
-	value: {
-		type: "object",
-		enabled: false
-	}
-} };
-const legacyDocToSchema2Key = (index, id, type, v1BaseIndex) => {
-	const legacyType = typeof type === "string" && type !== "" && type !== "_doc" ? type : null;
-	if (v1BaseIndex && index !== v1BaseIndex) {
-		const parts = index.slice(v1BaseIndex.length + 1).split("-");
-		if (parts.length !== 2) throw new Error(`unable to migrate records from index ${index} due to data ambiguity`);
-		if (legacyType != null) return `${parts[0]}:${decodeURIComponent(legacyType)}:${parts[1]}:${id}`;
-		const idParts = id.split(":");
-		if (idParts.length !== 2) throw new Error(`unable to migrate records from index ${index} due to data ambiguity`);
-		return `${parts[0]}:${idParts[0]}:${parts[1]}:${idParts[1]}`;
-	}
-	if (legacyType != null) return `${legacyType}:${id}`;
-	const idParts = id.split(":");
-	if (idParts.length !== 2) throw new Error(`unable to migrate records from index ${index} due to missing legacy type metadata`);
-	return `${idParts[0]}:${idParts[1]}`;
-};
-const migrateToSchema2 = async (client, v1BaseIndex, v2Index, logger) => {
-	let recordsMigratedLastLogged = 0;
-	let recordsMigrated = 0;
-	const totals = /* @__PURE__ */ new Map();
-	logger.info(`Attempting elasticsearch record migration from schema v1 at base index ${v1BaseIndex} to schema v2 at index ${v2Index}...`);
-	const indices = await client.indices.get({ index: [v1BaseIndex, `${v1BaseIndex}-*-*`] });
-	const scrollIds = /* @__PURE__ */ new Map();
-	const q = [];
-	try {
-		for (const index of Object.keys(indices)) {
-			const res = await client.search({
-				index,
-				scroll: "10m"
-			});
-			scrollIds.set(index, res._scroll_id);
-			q.push({
-				index,
-				res
-			});
-		}
-		while (q.length) {
-			const { index, res: { hits: { hits, total: { value: total } } } } = q.shift();
-			if (hits.length === 0) continue;
-			totals.set(index, total);
-			const body = [];
-			for (const { _id, _type, _source: { val } } of hits) {
-				const key = legacyDocToSchema2Key(index, _id, _type, v1BaseIndex);
-				body.push({ index: { _id: keyToId(key) } }, {
-					key,
-					value: JSON.parse(val)
-				});
-			}
-			await client.bulk({
-				index: v2Index,
-				body
-			});
-			recordsMigrated += hits.length;
-			if (Math.floor(recordsMigrated / 100) > Math.floor(recordsMigratedLastLogged / 100)) {
-				const total = [...totals.values()].reduce((a, b) => a + b, 0);
-				logger.info(`Migrated ${recordsMigrated} records out of ${total}`);
-				recordsMigratedLastLogged = recordsMigrated;
-			}
-			q.push({
-				index,
-				res: await client.scroll({
-					scroll: "5m",
-					scroll_id: scrollIds.get(index)
-				})
-			});
-		}
-		logger.info(`Finished migrating ${recordsMigrated} records`);
-	} finally {
-		await Promise.all([...scrollIds.values()].map((scrollId) => client.clearScroll({ scroll_id: scrollId })));
-	}
-};
-var elasticsearch_db_default = class extends AbstractDatabase {
-	_client;
-	_index;
-	_indexClean;
-	_q;
-	constructor(settings) {
-		super(settings);
-		this._client = null;
-		this.settings = {
-			host: "127.0.0.1",
-			port: "9200",
-			base_index: "ueberes",
-			migrate_to_newer_schema: false,
-			api: "7.6",
-			...settings || {},
-			json: false
-		};
-		this._index = `${this.settings.base_index}_s${schema}`;
-		this._q = { index: this._index };
-		this._indexClean = true;
-	}
-	get isAsync() {
-		return true;
-	}
-	async _refreshIndex() {
-		if (this._indexClean) return;
-		this._indexClean = true;
-		await this._client.indices.refresh(this._q);
-	}
-	/**
-	* Initialize the elasticsearch client, then ping the server to ensure that a
-	* connection was made.
-	*/
-	async init() {
-		const client = new _elastic_elasticsearch.Client({ node: `http://${this.settings.host}:${this.settings.port}` });
-		await client.ping();
-		if (!await client.indices.exists({ index: this._index })) {
-			let tmpIndex;
-			const exists = await client.indices.exists({ index: this.settings.base_index });
-			if (exists && !this.settings.migrate_to_newer_schema) throw new Error(`Data exists under the legacy index (schema) named ${this.settings.base_index}. Set migrate_to_newer_schema to true to copy the existing data to a new index named ${this._index}.`);
-			let attempt = 0;
-			while (true) {
-				tmpIndex = `${this._index}_${exists ? "migrate_attempt_" : "i"}${attempt++}`;
-				if (!await client.indices.exists({ index: tmpIndex })) break;
-			}
-			await client.indices.create({
-				index: tmpIndex,
-				mappings
-			});
-			if (exists) await migrateToSchema2(client, this.settings.base_index, tmpIndex, this.logger);
-			await client.indices.putAlias({
-				index: tmpIndex,
-				name: this._index
-			});
-		}
-		const indices = Object.values(await client.indices.get({ index: this._index }));
-		(0, assert.equal)(indices.length, 1);
-		try {
-			assert.default.deepEqual(indices[0].mappings, mappings);
-		} catch (err) {
-			this.logger.warn(`Index ${this._index} mappings does not match expected; attempting to use index anyway. Details: ${err}`);
-		}
-		this._client = client;
-	}
-	/**
-	*  This function provides read functionality to the database.
-	*
-	*  @param {String} key Key
-	*/
-	async get(key) {
-		const res = await this._client.get({
-			...this._q,
-			id: keyToId(key)
-		}, { ignore: [404] });
-		if (!res.found) return null;
-		return res._source.value;
-	}
-	/**
-	*  @param key Search key, which uses an asterisk (*) as the wild card.
-	*  @param notKey Used to filter the result set
-	*/
-	async findKeys(key, notKey) {
-		await this._refreshIndex();
-		const q = {
-			...this._q,
-			body: { query: { bool: {
-				filter: { wildcard: { key: { value: key } } },
-				...notKey == null ? {} : { must_not: { wildcard: { key: { value: notKey } } } }
-			} } }
-		};
-		const { hits } = await this._client.search(q);
-		return hits.hits.map((h) => h._source.key);
-	}
-	/**
-	*  This function provides write functionality to the database.
-	*
-	*  @param {String} key Record identifier.
-	*  @param {JSON|String} value The value to store in the database.
-	*/
-	async set(key, value) {
-		this._indexClean = false;
-		await this._client.index({
-			...this._q,
-			id: keyToId(key),
-			body: {
-				key,
-				value
-			}
-		});
-	}
-	/**
-	*  This function provides delete functionality to the database.
-	*
-	*  The index, type, and ID will be parsed from the key, and this document will
-	*  be deleted from the database.
-	*
-	*  @param {String} key Record identifier.
-	*/
-	async remove(key) {
-		this._indexClean = false;
-		await this._client.delete({
-			...this._q,
-			id: keyToId(key)
-		}, { ignore: [404] });
-	}
-	/**
-	*  This uses the bulk upload functionality of elasticsearch (url:port/_bulk).
-	*
-	*  The CacheAndBufferLayer will periodically (every this.settings.writeInterval)
-	*  flush writes that have already been done in the local cache out to the database.
-	*
-	*  @param {Array} bulk An array of JSON data in the format:
-	*      {"type":type, "key":key, "value":value}
-	*/
-	async doBulk(bulk) {
-		const operations = [];
-		for (const { type, key, value } of bulk) {
-			this._indexClean = false;
-			switch (type) {
-				case "set":
-					operations.push({ index: { _id: keyToId(key) } });
-					operations.push({
-						key,
-						value
-					});
-					break;
-				case "remove":
-					operations.push({ delete: { _id: keyToId(key) } });
-					break;
-				default:
-			}
-		}
-		await this._client.bulk({
-			...this._q,
-			body: operations
-		});
-	}
-	async close() {
-		if (this._client != null) this._client.close();
-		this._client = null;
-	}
-};
-//#endregion
-//#region databases/memory_db.ts
-var MemoryDB = class extends AbstractDatabase {
-	_data;
-	constructor(settings) {
-		super(settings);
-		this.settings = settings;
-		settings.json = false;
-		settings.cache = 0;
-		settings.writeInterval = 0;
-		this._data = null;
-	}
-	get isAsync() {
-		return true;
-	}
-	close() {
-		this._data = null;
-	}
-	findKeys(key, notKey) {
-		const regex = this.createFindRegex(key, notKey);
-		return [...this._data.keys()].filter((k) => regex.test(k));
-	}
-	get(key) {
-		return this._data.get(key);
-	}
-	init() {
-		this._data = this.settings.data || /* @__PURE__ */ new Map();
-	}
-	remove(key) {
-		this._data.delete(key);
-	}
-	set(key, value) {
-		this._data.set(key, value);
-	}
-};
-//#endregion
-//#region databases/mock_db.ts
-var mock_db_default = class extends events.default.EventEmitter {
-	settings;
-	mock;
-	constructor(settings) {
-		super();
-		this.settings = {
-			writeInterval: 1,
-			...settings
-		};
-		settings.mock = this;
-		this.settings = settings;
-	}
-	close(cb) {
-		this.emit("close", cb);
-	}
-	doBulk(ops, cb) {
-		this.emit("doBulk", ops, cb);
-	}
-	findKeys(key, notKey, cb) {
-		this.emit("findKeys", key, notKey, cb);
-	}
-	get(key, cb) {
-		this.emit("get", key, cb);
-	}
-	async init(cb) {
-		this.emit("init", cb());
-	}
-	remove(key, cb) {
-		this.emit("remove", key, cb);
-	}
-	set(key, value, cb) {
-		this.emit("set", key, value, cb);
-	}
-};
-//#endregion
-//#region databases/mongodb_db.ts
-/**
-* 2020 Sylchauf
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var mongodb_db_default = class extends AbstractDatabase {
-	interval;
-	database;
-	client;
-	collection;
-	constructor(settings) {
-		super(settings);
-		this.settings = settings;
-		if (!this.settings.url) throw new Error("You must specify a mongodb url");
-		if (this.settings.database == null) this.settings.database = this.settings.dbName;
-		if (!this.settings.collection) this.settings.collection = "ueberdb";
-	}
-	clearPing() {
-		if (this.interval) clearInterval(this.interval[Symbol.toPrimitive]());
-	}
-	schedulePing() {
-		this.clearPing();
-		this.interval = setInterval(() => {
-			this.database.command({ ping: 1 });
-		}, 1e4);
-	}
-	init(callback) {
-		mongodb.MongoClient.connect(this.settings.url).then((v) => {
-			this.client = v;
-			this.database = v.db(this.settings.database);
-			this.schedulePing();
-			this.collection = this.database.collection(this.settings.collection);
-			callback(null);
-		}).catch((v) => {
-			callback(v);
-		});
-	}
-	get(key, callback) {
-		this.collection.findOne({ _id: key }).then((v) => {
-			callback(null, v && v.value);
-		}).catch((v) => {
-			console.log(v);
-			callback(v);
-		});
-		this.schedulePing();
-	}
-	findKeys(key, notKey, callback) {
-		const selector = { $and: [{ _id: { $regex: `${key.replace(/\*/g, "")}` } }] };
-		if (notKey) selector.$and.push({ _id: { $not: { $regex: `${notKey.replace(/\*/g, "")}` } } });
-		this.collection.find(selector).map((i) => i._id).toArray().then((r) => {
-			callback(null, r);
-		}).catch((v) => callback(v));
-		this.schedulePing();
-	}
-	set(key, value, callback) {
-		if (key.length > 100) callback("Your Key can only be 100 chars");
-		else this.collection.updateMany({ _id: key }, { $set: { value } }, { upsert: true }).then(() => callback(null)).catch((v) => callback(v));
-		this.schedulePing();
-	}
-	remove(key, callback) {
-		this.collection.deleteOne({ _id: key }).then((r) => callback(null, r)).catch((v) => callback(v));
-		this.schedulePing();
-	}
-	doBulk(bulk, callback) {
-		const bulkMongo = this.collection.initializeOrderedBulkOp();
-		for (const i in bulk) if (bulk[i].type === "set") bulkMongo.find({ _id: bulk[i].key }).upsert().updateOne({ $set: { value: bulk[i].value } });
-		else if (bulk[i].type === "remove") bulkMongo.find({ _id: bulk[i].key }).deleteOne();
-		bulkMongo.execute().then((res) => {
-			callback(null, res);
-		}).catch((error) => {
-			callback(error);
-		});
-		this.schedulePing();
-	}
-	close(callback) {
-		this.clearPing();
-		this.client.close().then((r) => callback(r));
-	}
-};
-//#endregion
-//#region databases/mssql_db.ts
-/**
-* 2019 - exspecto@gmail.com
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*
-*
-* Note: This requires MS SQL Server >= 2008 due to the usage of the MERGE statement
-*
-*/
-var MSSQL = class extends AbstractDatabase {
-	db;
-	constructor(settings) {
-		super(settings);
-		settings = settings || {};
-		if (settings.json != null) settings.parseJSON = settings.json;
-		settings.requestTimeout = 3e5;
-		settings.server = settings.host;
-		this.settings = settings;
-		this.settings.cache = 0;
-		this.settings.writeInterval = 0;
-	}
-	init(callback) {
-		const sqlCreate = "IF OBJECT_ID(N'dbo.store', N'U') IS NULL  BEGIN    CREATE TABLE [store] (      [key] NVARCHAR(100) PRIMARY KEY,      [value] NTEXT NOT NULL    );  END";
-		new mssql.default.ConnectionPool(this.settings).connect().then((pool) => {
-			this.db = pool;
-			new mssql.default.Request(this.db).query(sqlCreate, (err) => {
-				callback(err);
-			});
-			this.db.on("error", (err) => {
-				console.log(err);
-			});
-		});
-	}
-	get(key, callback) {
-		const request = new mssql.default.Request(this.db);
-		request.input("key", mssql.default.NVarChar(100), key);
-		request.query("SELECT [value] FROM [store] WHERE [key] = @key", (err, results) => {
-			let value = null;
-			if (!err && results && results.rowsAffected[0] === 1) value = results.recordset[0].value;
-			callback(err, value);
-		});
-	}
-	findKeys(key, notKey, callback) {
-		const request = new mssql.default.Request(this.db);
-		let query = "SELECT [key] FROM [store] WHERE [key] LIKE @key";
-		key = key.replace(/\*/g, "%");
-		request.input("key", mssql.default.NVarChar(100), key);
-		if (notKey != null) {
-			notKey = notKey.replace(/\*/g, "%");
-			request.input("notkey", mssql.default.NVarChar(100), notKey);
-			query += " AND [key] NOT LIKE @notkey";
-		}
-		request.query(query, (err, results) => {
-			const value = [];
-			if (!err && results && results.rowsAffected[0] > 0) for (let i = 0; i < results.recordset.length; i++) value.push(results.recordset[i].key);
-			callback(err, value);
-		});
-	}
-	set(key, value, callback) {
-		const request = new mssql.default.Request(this.db);
-		if (key.length > 100) callback("Your Key can only be 100 chars");
-		else {
-			const query = "MERGE [store] t USING (SELECT @key [key], @value [value]) s ON t.[key] = s.[key] WHEN MATCHED AND s.[value] IS NOT NULL THEN UPDATE SET t.[value] = s.[value] WHEN NOT MATCHED THEN INSERT ([key], [value]) VALUES (s.[key], s.[value]);";
-			request.input("key", mssql.default.NVarChar(100), key);
-			request.input("value", mssql.default.NText, value);
-			request.query(query, (err, info) => {
-				callback(err ? err.toString() : "");
-			});
-		}
-	}
-	remove(key, callback) {
-		const request = new mssql.default.Request(this.db);
-		request.input("key", mssql.default.NVarChar(100), key);
-		request.query("DELETE FROM [store] WHERE [key] = @key", callback);
-	}
-	doBulk(bulk, callback) {
-		const maxInserts = 100;
-		const request = new mssql.default.Request(this.db);
-		let firstReplace = true;
-		let firstRemove = true;
-		const replacements = [];
-		let removeSQL = "DELETE FROM [store] WHERE [key] IN (";
-		for (const i in bulk) if (bulk[i].type === "set") {
-			if (firstReplace) {
-				replacements.push("BEGIN TRANSACTION;");
-				firstReplace = false;
-			} else if (Number(i) % maxInserts === 0) replacements.push("\nCOMMIT TRANSACTION;\nBEGIN TRANSACTION;\n");
-			replacements.push(`MERGE [store] t USING (SELECT '${bulk[i].key}' [key], '${bulk[i].value}' [value]) s`, "ON t.[key] = s.[key]", "WHEN MATCHED AND s.[value] IS NOT NULL THEN UPDATE SET t.[value] = s.[value]", "WHEN NOT MATCHED THEN INSERT ([key], [value]) VALUES (s.[key], s.[value]);");
-		} else if (bulk[i].type === "remove") {
-			if (!firstRemove) removeSQL += ",";
-			firstRemove = false;
-			removeSQL += `'${bulk[i].key}'`;
-		}
-		removeSQL += ");";
-		replacements.push("COMMIT TRANSACTION;");
-		async.default.parallel([(callback) => {
-			if (!firstReplace) request.batch(replacements.join("\n"), (err, results) => {
-				if (err) callback(err);
-				callback(err, results);
-			});
-			else callback();
-		}, (callback) => {
-			if (!firstRemove) request.query(removeSQL, callback);
-			else callback();
-		}], (err, results) => {
-			if (err) callback(err);
-			callback(err, results);
-		});
-	}
-	close(callback) {
-		this.db && this.db.close(callback);
-	}
-};
-//#endregion
-//#region databases/mysql_db.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var mysql_db_default = class extends AbstractDatabase {
-	_mysqlSettings;
-	_pool;
-	constructor(settings) {
-		super(settings);
-		this.logger = console;
-		this._mysqlSettings = {
-			charset: "utf8mb4",
-			...settings
-		};
-		this.settings = {
-			engine: "InnoDB",
-			bulkLimit: 100,
-			json: true,
-			queryTimeout: 6e4
-		};
-		this._pool = null;
-	}
-	get isAsync() {
-		return true;
-	}
-	async _query(options) {
-		try {
-			return await new Promise((resolve, reject) => {
-				options = {
-					timeout: this.settings.queryTimeout,
-					...options
-				};
-				this._pool && this._pool.query(options, (err, ...args) => err != null ? reject(err) : resolve(args));
-			});
-		} catch (err) {
-			this.logger.error(`${err.fatal ? "Fatal " : ""}MySQL error: ${err.stack || err}`);
-			throw err;
-		}
-	}
-	async init() {
-		if ("speeds" in this._mysqlSettings) delete this._mysqlSettings.speeds;
-		if ("filename" in this._mysqlSettings) delete this._mysqlSettings.filename;
-		this._pool = (0, mysql2.createPool)(this._mysqlSettings);
-		const { database, charset } = this._mysqlSettings;
-		const sqlCreate = `CREATE TABLE IF NOT EXISTS \`store\` ( \`key\` VARCHAR( 100 ) NOT NULL COLLATE utf8mb4_bin, \`value\` LONGTEXT COLLATE utf8mb4_bin NOT NULL , PRIMARY KEY ( \`key\` ) ) ENGINE=${this.settings.engine} CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`;
-		const sqlAlter = "ALTER TABLE store MODIFY `key` VARCHAR(100) COLLATE utf8mb4_bin;";
-		await this._query({ sql: sqlCreate });
-		const dbCharSet = `SELECT DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = '${database}'`;
-		let [result] = await this._query({ sql: dbCharSet });
-		result = JSON.parse(JSON.stringify(result));
-		if (result[0].DEFAULT_CHARACTER_SET_NAME !== charset) {
-			this.logger.error(`Database is not configured with charset ${charset} -- This may lead to crashes when certain characters are pasted in pads`);
-			this.logger.warn(result[0], charset);
-		}
-		if (result[0].DEFAULT_COLLATION_NAME.indexOf(charset) === -1) {
-			this.logger.error(`Database is not configured with collation name that includes ${charset} -- This may lead to crashes when certain characters are pasted in pads`);
-			this.logger.warn(result[0], charset, result[0].DEFAULT_COLLATION_NAME);
-		}
-		const tableCharSet = `SELECT CCSA.character_set_name AS character_set_name FROM information_schema.\`TABLES\` T,information_schema.\`COLLATION_CHARACTER_SET_APPLICABILITY\` CCSA WHERE CCSA.collation_name = T.table_collation AND T.table_schema = '${database}' AND T.table_name = 'store'`;
-		[result] = await this._query({ sql: tableCharSet });
-		if (!result[0]) this.logger.warn("Data has no character_set_name value -- This may lead to crashes when certain characters are pasted in pads");
-		if (result[0] && result[0].character_set_name !== charset) {
-			this.logger.error(`table is not configured with charset ${charset} -- This may lead to crashes when certain characters are pasted in pads`);
-			this.logger.warn(result[0], charset);
-		}
-		if (await this.get("MYSQL_MIGRATION_LEVEL") !== "1") {
-			await this._query({ sql: sqlAlter });
-			await this.set("MYSQL_MIGRATION_LEVEL", "1");
-		}
-	}
-	async get(key) {
-		const [results] = await this._query({
-			sql: "SELECT `value` FROM `store` WHERE `key` = ? AND BINARY `key` = ?",
-			values: [key, key]
-		});
-		return results.length === 1 ? results[0].value : null;
-	}
-	async findKeys(key, notKey) {
-		let query = "SELECT `key` FROM `store` WHERE `key` LIKE ?";
-		const params = [];
-		key = key.replace(/\*/g, "%");
-		params.push(key);
-		if (notKey != null) {
-			notKey = notKey.replace(/\*/g, "%");
-			query += " AND `key` NOT LIKE ?";
-			params.push(notKey);
-		}
-		const [results] = await this._query({
-			sql: query,
-			values: params
-		});
-		return results.map((val) => val.key);
-	}
-	async set(key, value) {
-		if (key.length > 100) throw new Error("Your Key can only be 100 chars");
-		await this._query({
-			sql: "REPLACE INTO `store` VALUES (?,?)",
-			values: [key, value]
-		});
-	}
-	async remove(key) {
-		await this._query({
-			sql: "DELETE FROM `store` WHERE `key` = ? AND BINARY `key` = ?",
-			values: [key, key]
-		});
-	}
-	async doBulk(bulk) {
-		const replaces = [];
-		const deletes = [];
-		for (const op of bulk) switch (op.type) {
-			case "set":
-				replaces.push([op.key, op.value]);
-				break;
-			case "remove":
-				deletes.push(op.key);
-				break;
-			default: throw new Error(`unknown op type: ${op.type}`);
-		}
-		await Promise.all([replaces.length ? this._query({
-			sql: "REPLACE INTO `store` VALUES ?;",
-			values: [replaces]
-		}) : null, deletes.length ? this._query({
-			sql: "DELETE FROM `store` WHERE `key` IN (?) AND BINARY `key` IN (?);",
-			values: [deletes, deletes]
-		}) : null]);
-	}
-	async close() {
-		await util.default.promisify(this._pool.end.bind(this._pool))();
-	}
-};
-//#endregion
-//#region databases/postgres_db.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var postgres_db_default = class extends AbstractDatabase {
-	db;
-	upsertStatement;
-	constructor(settings) {
-		super(settings);
-		if (typeof settings === "string") settings = { connectionString: settings };
-		this.settings = settings;
-		this.settings.cache = settings.cache || 1e3;
-		this.settings.writeInterval = 100;
-		this.settings.json = true;
-		this.settings.max = this.settings.max || 20;
-		this.settings.min = this.settings.min || 4;
-		this.settings.idleTimeoutMillis = this.settings.idleTimeoutMillis || 1e3;
-		this.db = new pg.Pool(this.settings);
-	}
-	init(callback) {
-		const testTableExists = "SELECT 1 as exists FROM pg_tables WHERE tablename = 'store'";
-		const createTable = "CREATE TABLE IF NOT EXISTS store (\"key\" character varying(100) NOT NULL, \"value\" text NOT NULL, CONSTRAINT store_pkey PRIMARY KEY (key))";
-		this.upsertStatement = null;
-		const detectUpsertMethod = (callback) => {
-			const upsertViaFunction = "SELECT ueberdb_insert_or_update($1,$2)";
-			const upsertNatively = "INSERT INTO store(key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = excluded.value";
-			const createFunc = "CREATE OR REPLACE FUNCTION ueberdb_insert_or_update(character varying, text) RETURNS void AS $$ BEGIN   IF EXISTS( SELECT * FROM store WHERE key = $1 ) THEN     UPDATE store SET value = $2 WHERE key = $1;   ELSE     INSERT INTO store(key,value) VALUES( $1, $2 );   END IF;   RETURN; END; $$ LANGUAGE plpgsql;";
-			const testNativeUpsert = `EXPLAIN ${upsertNatively}`;
-			this.db.query(testNativeUpsert, ["test-key", "test-value"], (err) => {
-				if (err) {
-					this.upsertStatement = upsertViaFunction;
-					this.db.query(createFunc, [], callback);
-					return;
-				}
-				this.upsertStatement = upsertNatively;
-				callback();
-			});
-		};
-		this.db.query(testTableExists, (err, result) => {
-			if (err != null) return callback(err);
-			if (result.rows.length === 0) this.db.query(createTable, (err) => {
-				if (err != null) return callback(err);
-				detectUpsertMethod(callback);
-			});
-			else detectUpsertMethod(callback);
-		});
-	}
-	get(key, callback) {
-		this.db.query("SELECT value FROM store WHERE key=$1", [key], (err, results) => {
-			let value = null;
-			if (!err && results.rows.length === 1) value = results.rows[0].value;
-			callback(err, value);
-		});
-	}
-	findKeys(key, notKey, callback) {
-		let query = "SELECT key FROM store WHERE key LIKE $1";
-		const params = [];
-		key = key.replace(/\*/g, "%");
-		params.push(key);
-		if (notKey != null) {
-			notKey = notKey.replace(/\*/g, "%");
-			query += " AND key NOT LIKE $2";
-			params.push(notKey);
-		}
-		this.db.query(query, params, (err, results) => {
-			const value = [];
-			if (!err && results.rows.length > 0) results.rows.forEach((val) => {
-				value.push(val.key);
-			});
-			callback(err, value);
-		});
-	}
-	set(key, value, callback) {
-		if (key.length > 100) callback(Error("Your Key can only be 100 chars"), "");
-		else if (this.upsertStatement != null) this.db.query(this.upsertStatement, [key, value], callback);
-	}
-	remove(key, callback) {
-		this.db.query("DELETE FROM store WHERE key=$1", [key], callback);
-	}
-	doBulk(bulk, callback) {
-		const replaceVALs = [];
-		let removeSQL = "DELETE FROM store WHERE key IN (";
-		const removeVALs = [];
-		let removeCount = 0;
-		for (const i in bulk) if (bulk[i].type === "set") replaceVALs.push([bulk[i].key, bulk[i].value]);
-		else if (bulk[i].type === "remove") {
-			if (removeCount !== 0) removeSQL += ",";
-			removeCount += 1;
-			removeSQL += `$${removeCount}`;
-			removeVALs.push(bulk[i].key);
-		}
-		removeSQL += ");";
-		if (!this.upsertStatement) return;
-		const functions = replaceVALs.map((v) => (cb) => this.db.query(this.upsertStatement, v, cb));
-		const removeFunction = (callback) => {
-			if (!(removeVALs.length < 1)) this.db.query(removeSQL, removeVALs, callback);
-			else callback();
-		};
-		functions.push(removeFunction);
-		async.default.parallel(functions, callback);
-	}
-	close(callback) {
-		this.db.end(callback);
-	}
-};
-//#endregion
-//#region databases/postgrespool_db.ts
-var PostgresDB = class extends postgres_db_default {
-	constructor(settings) {
-		console.warn("ueberdb: The postgrespool database driver is deprecated and will be removed in a future version. Use postgres instead.");
-		super(settings);
-	}
-};
-//#endregion
-//#region databases/redis_db.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var RedisDB = class extends AbstractDatabase {
-	_client;
-	constructor(settings) {
-		super(settings);
-		this._client = null;
-		this.settings = settings || {};
-	}
-	get isAsync() {
-		return true;
-	}
-	async init() {
-		if (this.settings.url) this._client = (0, redis.createClient)({ url: this.settings.url });
-		else if (this.settings.host) {
-			const options = { socket: {
-				host: this.settings.host,
-				port: Number(this.settings.port)
-			} };
-			if (this.settings.password) options.password = this.settings.password;
-			if (this.settings.user) options.username = this.settings.user;
-			this._client = (0, redis.createClient)(options);
-		}
-		if (this._client) {
-			await this._client.connect();
-			await this._client.ping();
-		}
-	}
-	async get(key) {
-		if (this._client == null) return null;
-		return await this._client.get(key);
-	}
-	async findKeys(key, notKey) {
-		if (this._client == null) return null;
-		const [_, type] = /^([^:*]+):\*$/.exec(key) || [];
-		if (type != null && ["*:*:*", `${key}:*`].includes(notKey)) return await this._client.sMembers(`ueberDB:keys:${type}`);
-		let keys = await this._client.keys(key.replace(/[?[\]\\]/g, "\\$&"));
-		if (notKey != null) {
-			const regex = this.createFindRegex(key, notKey);
-			keys = keys.filter((k) => regex.test(k));
-		}
-		return keys;
-	}
-	async set(key, value) {
-		if (this._client == null) return null;
-		const matches = /^([^:]+):([^:]+)$/.exec(key);
-		await Promise.all([matches && this._client.sAdd(`ueberDB:keys:${matches[1]}`, matches[0]), this._client.set(key, value)]);
-	}
-	async remove(key) {
-		if (this._client == null) return null;
-		const matches = /^([^:]+):([^:]+)$/.exec(key);
-		await Promise.all([matches && this._client.sRem(`ueberDB:keys:${matches[1]}`, matches[0]), this._client.del(key)]);
-	}
-	async doBulk(bulk) {
-		if (this._client == null) return null;
-		const multi = this._client.multi();
-		for (const { key, type, value } of bulk) {
-			const matches = /^([^:]+):([^:]+)$/.exec(key);
-			if (type === "set") {
-				if (matches) multi.sAdd(`ueberDB:keys:${matches[1]}`, matches[0]);
-				multi.set(key, value);
-			} else if (type === "remove") {
-				if (matches) multi.sRem(`ueberDB:keys:${matches[1]}`, matches[0]);
-				multi.del(key);
-			}
-		}
-		await multi.exec();
-	}
-	async close() {
-		if (this._client == null) return null;
-		await this._client.quit();
-		this._client = null;
-	}
-};
-//#endregion
-//#region databases/rethink_db.ts
-/**
-* 2016 Remi Arnaud
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var Rethink_db = class extends AbstractDatabase {
-	host;
-	db;
-	port;
-	table;
-	connection;
-	constructor(settings) {
-		super(settings);
-		if (!settings) settings = {};
-		if (!settings.host) settings.host = "localhost";
-		if (!settings.port) settings.port = 28015;
-		if (!settings.db) settings.db = "test";
-		if (!settings.table) settings.table = "test";
-		this.host = settings.host;
-		this.db = settings.db;
-		this.port = settings.port;
-		this.table = settings.table;
-		this.connection = null;
-	}
-	init(callback) {
-		rethinkdb.default.connect(this, (err, conn) => {
-			if (err) throw err;
-			this.connection = conn;
-			rethinkdb.default.table(this.table).run(this.connection, (err, cursor) => {
-				if (err) rethinkdb.default.tableCreate(this.table).run(this.connection, callback);
-				else if (callback) callback(null, cursor);
-			});
-		});
-	}
-	get(key, callback) {
-		rethinkdb.default.table(this.table).get(key).run(this.connection, (err, item) => {
-			callback(err, item ? item.content : item);
-		});
-	}
-	findKeys(key, notKey, callback) {
-		const keys = [];
-		const regex = this.createFindRegex(key, notKey);
-		rethinkdb.default.filter((item) => {
-			if (item.id.search(regex) !== -1) keys.push(item.id);
-		}).run(this.connection, callback);
-	}
-	set(key, value, callback) {
-		rethinkdb.default.table(this.table).insert({
-			id: key,
-			content: value
-		}, { conflict: "replace" }).run(this.connection, callback);
-	}
-	doBulk(bulk, callback) {
-		const _in = [];
-		const _out = [];
-		for (const i in bulk) if (bulk[i].type === "set") _in.push({
-			id: bulk[i].key,
-			content: bulk[i].value
-		});
-		else if (bulk[i].type === "remove") _out.push(bulk[i].key);
-		async.default.parallel([(cb) => {
-			rethinkdb.default.table(this.table).insert(_in, { conflict: "replace" }).run(this.connection, cb);
-		}, (cb) => {
-			rethinkdb.default.table(this.table).getAll(_out).delete().run(this.connection, cb);
-		}], callback);
-	}
-	remove(key, callback) {
-		rethinkdb.default.table(this.table).get(key).delete().run(this.connection, callback);
-	}
-	close(callback) {
-		if (this.connection) this.connection.close(callback);
-	}
-};
-//#endregion
-//#region databases/sqlite_db.ts
-/**
-* 2011 Peter 'Pita' Martischka
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-var SQLiteDB = class extends AbstractDatabase {
-	db;
-	constructor(settings) {
-		super(settings);
-		this.db = null;
-		if (!settings || !settings.filename) settings = { filename: ":memory:" };
-		this.settings = settings;
-		if (settings.filename === ":memory:") {
-			this.settings.cache = 0;
-			this.settings.writeInterval = 0;
-			this.settings.json = true;
-		} else {
-			this.settings.cache = 1e3;
-			this.settings.writeInterval = 100;
-			this.settings.json = true;
-		}
-	}
-	init(callback) {
-		this.db = new rusty_store_kv.SQLite(this.settings.filename);
-		callback();
-	}
-	get(key, callback) {
-		const res = this.db.get(key);
-		callback(null, res ? res : null);
-	}
-	findKeys(key, notKey, callback) {
-		const res = this.db?.findKeys(key, notKey);
-		callback(null, res);
-	}
-	set(key, value, callback) {
-		const res = this.db.set(key, value);
-		res ? callback(null, null) : callback(null, res);
-	}
-	remove(key, callback) {
-		this.db.remove(key);
-		callback(null, null);
-	}
-	doBulk(bulk, callback) {
-		const convertedBulk = bulk.map((b) => {
-			if (b.value === null) return {
-				key: b.key,
-				type: b.type
-			};
-			else return b;
-		});
-		this.db.doBulk(convertedBulk);
-		callback();
-	}
-	close(callback) {
-		callback();
-		this.db.close();
-	}
-};
-//#endregion
-//#region databases/surrealdb_db.ts
-/**
-* 2023 Samuel Schwanzer
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS-IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-const DATABASE = "ueberdb";
-const WILDCARD = "*";
-const replaceAt = function(index, replacement, original) {
-	return original.substring(0, index) + replacement + original.substring(index + replacement.length);
-};
-const escapeKey = (key) => {
-	const index = key.indexOf(":");
-	if (index > -1) return replaceAt(index, "_", key);
-	return key;
-};
-const unescapeKey = (key, originalKey) => {
-	const index = originalKey.indexOf(":");
-	if (index > -1) return replaceAt(index, ":", key);
-	return key;
-};
-var SurrealDB = class extends AbstractDatabase {
-	_client;
-	constructor(settings) {
-		super(settings);
-		this._client = null;
-	}
-	get isAsync() {
-		return true;
-	}
-	async init() {
-		if (this.settings.url) {
-			this._client = new surrealdb.Surreal();
-			await this._client.connect(this.settings.url);
-		} else if (this.settings.host) {
-			const port = this.settings.port || 8e3;
-			const protocol = this.settings.clientOptions?.protocol || "http://";
-			const path = this.settings.clientOptions?.path || "/rpc";
-			const host = this.settings.host;
-			this._client = new surrealdb.Surreal();
-			await this._client.connect(`${protocol}${host}:${port}${path}`);
-		}
-		if (this.settings.user && this.settings.password) await this._client.signin({
-			username: this.settings.user,
-			password: this.settings.password
-		});
-		await this._client.use({
-			namespace: DATABASE,
-			database: DATABASE
-		});
-	}
-	async get(key) {
-		if (this._client == null) return null;
-		key = escapeKey(key);
-		const rows = (await this._client.query("SELECT key, value FROM store WHERE key = $key", { key }))[0] || [];
-		if (rows.length === 0) return null;
-		const row = rows[0];
-		if (typeof row === "string") return row;
-		return unescapeKey(row.value, key);
-	}
-	async findKeys(key, notKey) {
-		if (this._client == null) return null;
-		const queryString = notKey != null ? `SELECT key FROM store WHERE ${this.transformWildcard(key, "key")} AND ${this.transformWildcardNegative(notKey, "notKey")}` : `SELECT key FROM store WHERE ${this.transformWildcard(key, "key")}`;
-		const cleanKey = key.replace(WILDCARD, "");
-		const cleanNotKey = (notKey || "").replace(WILDCARD, "");
-		const bindings = { key: cleanKey };
-		if (notKey != null) bindings.notKey = cleanNotKey;
-		const res = await this._client.query(queryString, bindings);
-		return this.transformResult(res[0] || [], cleanKey);
-	}
-	transformWildcard(key, keyExpr) {
-		if (key.startsWith(WILDCARD) && key.endsWith(WILDCARD)) return `${keyExpr} CONTAINS $${keyExpr}`;
-		else if (key.startsWith(WILDCARD)) return `string::ends_with(${keyExpr}, $${keyExpr})`;
-		else if (key.endsWith(WILDCARD)) return `string::starts_with(${keyExpr}, $${keyExpr})`;
-		else return `${keyExpr} = $${keyExpr}`;
-	}
-	transformWildcardNegative(key, keyExpr) {
-		if (key.startsWith(WILDCARD) && key.endsWith(WILDCARD)) return `key CONTAINSNOT $${keyExpr}`;
-		else if (key.startsWith(WILDCARD)) return `string::ends_with(key, $${keyExpr}) == false`;
-		else if (key.endsWith(WILDCARD)) return `string::starts_with(key, $${keyExpr}) == false`;
-		else return `key != $${keyExpr}`;
-	}
-	transformResult(rows, originalKey) {
-		const value = [];
-		if (typeof rows === "string") {
-			value.push(unescapeKey(rows, originalKey));
-			return value;
-		}
-		for (const row of rows) value.push(unescapeKey(row.key, originalKey));
-		return value;
-	}
-	async set(key, value) {
-		if (this._client == null) return null;
-		const exists = await this.get(key);
-		const escapedKey = escapeKey(key);
-		if (exists) await this._client.query("UPDATE store SET value = $value WHERE key = $key", {
-			key: escapedKey,
-			value
-		});
-		else await this._client.query("INSERT INTO store (key, value) VALUES ($key, $value)", {
-			key: escapedKey,
-			value
-		});
-	}
-	async remove(key) {
-		if (this._client == null) return null;
-		key = escapeKey(key);
-		return await this._client.query("DELETE FROM store WHERE key = $key", { key });
-	}
-	async doBulk(bulk) {
-		if (this._client == null) return null;
-		for (const b of bulk) if (b.type === "set") await this.set(b.key, b.value);
-		else if (b.type === "remove") await this.remove(b.key);
-	}
-	async close() {
-		if (this._client == null) return null;
-		await this._client.close();
-		this._client = null;
-	}
-};
-//#endregion
-//#region databases/rusty_db.ts
-var Rusty_db = class extends AbstractDatabase {
-	db;
-	constructor(settings) {
-		super(settings);
-		this.settings.cache = 0;
-		this.settings.writeInterval = 0;
-		this.settings.json = false;
-	}
-	get isAsync() {
-		return true;
-	}
-	findKeys(key, notKey) {
-		return this.db.findKeys(key, notKey);
-	}
-	get(key) {
-		const val = this.db.get(key);
-		if (!val) return val;
-		try {
-			return JSON.parse(val);
-		} catch (e) {
-			return val;
-		}
-	}
-	async init() {
-		this.db = new rusty_store_kv.KeyValueDB(this.settings.filename);
-	}
-	close() {
-		this.db?.close();
-		this.db = null;
-	}
-	remove(key) {
-		this.db.remove(key);
-	}
-	set(key, value) {
-		if (typeof value === "object") {
-			const valStr = JSON.stringify(value);
-			this.db.set(key, valStr);
-		} else this.db.set(key, value.toString());
-	}
-	destroy() {
-		this.db.destroy();
-	}
-};
-//#endregion
+require("./_virtual/_rolldown/runtime.js");
+const require_CacheAndBufferLayer = require("./lib/CacheAndBufferLayer.js");
+const require_logging = require("./lib/logging.js");
+let util = require("util");
 //#region index.ts
 /**
 * 2011 Peter 'Pita' Martischka
@@ -2295,7 +45,7 @@ for (const fn of [
 	"remove",
 	"set",
 	"setSub"
-]) if (fn in cbDb) cbDb[fn] = (0, util.callbackify)(Database$1.prototype[fn]);
+]) if (fn in cbDb) cbDb[fn] = (0, util.callbackify)(require_CacheAndBufferLayer.Database.prototype[fn]);
 const makeDoneCallback = (callback, deprecated) => (err) => {
 	if (callback) callback(err);
 	if (deprecated) deprecated(err);
@@ -2326,38 +76,40 @@ var Database = class {
 		this.type = type;
 		this.dbSettings = dbSettings;
 		this.wrapperSettings = wrapperSettings;
-		this.logger = normalizeLogger(logger);
+		this.logger = require_logging.normalizeLogger(logger);
 	}
 	/**
 	* @param callback - Deprecated. Node-style callback. If null, a Promise is returned.
 	*/
 	init(callback = null) {
-		const db = this.initDB();
-		db.logger = this.logger;
-		this.db = new Database$1(db, this.wrapperSettings, this.logger);
-		this.metrics = this.db.metrics;
-		if (callback != null) return cbDb.init.call(this.db);
-		return this.db.init();
+		const p = this.initDB().then((db) => {
+			db.logger = this.logger;
+			this.db = new require_CacheAndBufferLayer.Database(db, this.wrapperSettings, this.logger);
+			this.metrics = this.db.metrics;
+			return this.db.init();
+		});
+		if (callback != null) return cbDb.init.call({ init: () => p });
+		return p;
 	}
-	initDB() {
+	async initDB() {
 		switch (this.type) {
-			case "mysql": return new mysql_db_default(this.dbSettings);
-			case "postgres": return new postgres_db_default(this.dbSettings);
-			case "sqlite": return new SQLiteDB(this.dbSettings);
-			case "rustydb": return new Rusty_db(this.dbSettings);
-			case "mongodb": return new mongodb_db_default(this.dbSettings);
-			case "redis": return new RedisDB(this.dbSettings);
-			case "cassandra": return new Cassandra_db(this.dbSettings);
-			case "dirty": return new dirty_db_default(this.dbSettings);
-			case "dirtygit": return new dirty_git_db_default(this.dbSettings);
-			case "elasticsearch": return new elasticsearch_db_default(this.dbSettings);
-			case "memory": return new MemoryDB(this.dbSettings);
-			case "mock": return new mock_db_default(this.dbSettings);
-			case "mssql": return new MSSQL(this.dbSettings);
-			case "postgrespool": return new PostgresDB(this.dbSettings);
-			case "rethink": return new Rethink_db(this.dbSettings);
-			case "couch": return new Couch_db(this.dbSettings);
-			case "surrealdb": return new SurrealDB(this.dbSettings);
+			case "mysql": return new (await (Promise.resolve().then(() => require("./databases/mysql_db.js")))).default(this.dbSettings);
+			case "postgres": return new (await (Promise.resolve().then(() => require("./databases/postgres_db.js")))).default(this.dbSettings);
+			case "sqlite": return new (await (Promise.resolve().then(() => require("./databases/sqlite_db.js")))).default(this.dbSettings);
+			case "rustydb": return new (await (Promise.resolve().then(() => require("./databases/rusty_db.js")))).default(this.dbSettings);
+			case "mongodb": return new (await (Promise.resolve().then(() => require("./databases/mongodb_db.js")))).default(this.dbSettings);
+			case "redis": return new (await (Promise.resolve().then(() => require("./databases/redis_db.js")))).default(this.dbSettings);
+			case "cassandra": return new (await (Promise.resolve().then(() => require("./databases/cassandra_db.js")))).default(this.dbSettings);
+			case "dirty": return new (await (Promise.resolve().then(() => require("./databases/dirty_db.js")))).default(this.dbSettings);
+			case "dirtygit": return new (await (Promise.resolve().then(() => require("./databases/dirty_git_db.js")))).default(this.dbSettings);
+			case "elasticsearch": return new (await (Promise.resolve().then(() => require("./databases/elasticsearch_db.js")))).default(this.dbSettings);
+			case "memory": return new (await (Promise.resolve().then(() => require("./databases/memory_db.js")))).default(this.dbSettings);
+			case "mock": return new (await (Promise.resolve().then(() => require("./databases/mock_db.js")))).default(this.dbSettings);
+			case "mssql": return new (await (Promise.resolve().then(() => require("./databases/mssql_db.js")))).default(this.dbSettings);
+			case "postgrespool": return new (await (Promise.resolve().then(() => require("./databases/postgrespool_db.js")))).default(this.dbSettings);
+			case "rethink": return new (await (Promise.resolve().then(() => require("./databases/rethink_db.js")))).default(this.dbSettings);
+			case "couch": return new (await (Promise.resolve().then(() => require("./databases/couch_db.js")))).default(this.dbSettings);
+			case "surrealdb": return new (await (Promise.resolve().then(() => require("./databases/surrealdb_db.js")))).default(this.dbSettings);
 			default: throw new Error("Invalid database type");
 		}
 	}