lakutata 2.0.96 → 2.0.97

package/vendor/Package.internal.11.cjs

@@ -1,1619 +1,26 @@
-/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:10:51 GMT+0800 (China Standard Time) */
 "use strict";
 
-const t = require("buffer");
+const e = require("./Package.internal.51.cjs");
 
-const e = require("./Package.internal.12.cjs");
+var t = {};
 
-const s = require("./Package.internal.13.cjs");
-
-const i = require("./Package.internal.14.cjs");
-
-const r = require("./Package.internal.15.cjs");
-
-const n = require("events");
-
-const a = require("memjs");
-
-const o = require("mongodb");
-
-const c = require("util");
-
-const l = require("sqlite3");
-
-const u = require("pg");
-
-const h = require("mysql2");
-
-const f = t => t && t.__esModule ? t : {
-    default: t
-};
-
-const y = f(t);
-
-const p = f(n);
-
-const d = f(a);
-
-const m = f(l);
-
-const E = f(u);
-
-const w = f(h);
-
-var S = (e, s = true) => {
-    if (e === void 0 || e === null) {
-        return "null";
-    }
-    if (typeof e === "string") {
-        return JSON.stringify(s && e.startsWith(":") ? `:${e}` : e);
-    }
-    if (t.Buffer.isBuffer(e)) {
-        return JSON.stringify(`:base64:${e.toString("base64")}`);
-    }
-    if (e?.toJSON) {
-        e = e.toJSON();
-    }
-    if (typeof e === "object") {
-        let t = "";
-        const i = Array.isArray(e);
-        t = i ? "[" : "{";
-        let r = true;
-        for (const n in e) {
-            const a = typeof e[n] === "function" || !i && e[n] === void 0;
-            if (!Object.hasOwn(e, n) || a) {
-                continue;
-            }
-            if (!r) {
-                t += ",";
-            }
-            r = false;
-            if (i) {
-                t += S(e[n], s);
-            } else if (e[n] !== void 0) {
-                t += `${S(n, false)}:${S(e[n], s)}`;
-            }
-        }
-        t += i ? "]" : "}";
-        return t;
-    }
-    return JSON.stringify(e);
-};
-
-exports.defaultSerialize = t => S(t, true);
-
-exports.defaultDeserialize = e => JSON.parse(e, (e, s) => {
-    if (typeof s === "string") {
-        if (s.startsWith(":base64:")) {
-            return t.Buffer.from(s.slice(8), "base64");
-        }
-        return s.startsWith(":") ? s.slice(1) : s;
-    }
-    return s;
+Object.defineProperty(t, "__esModule", {
+    value: true
 });
 
-var v;
+exports.AfterInsert_2 = t.AfterInsert = s;
 
-var g;
+const r = e.requireGlobals();
 
-function b() {
-    if (g) return v;
-    g = 1;
-    var t = Object.defineProperty;
-    var e = Object.getOwnPropertyDescriptor;
-    var s = Object.getOwnPropertyNames;
-    var i = Object.prototype.hasOwnProperty;
-    var r = (e, s) => {
-        for (var i in s) t(e, i, {
-            get: s[i],
-            enumerable: true
-        });
-    };
-    var n = (r, n, a, o) => {
-        if (n && typeof n === "object" || typeof n === "function") {
-            for (let c of s(n)) if (!i.call(r, c) && c !== a) t(r, c, {
-                get: () => n[c],
-                enumerable: !(o = e(n, c)) || o.enumerable
-            });
-        }
-        return r;
-    };
-    var a = e => n(t({}, "__esModule", {
-        value: true
-    }), e);
-    var o = {};
-    r(o, {
-        defaultDeserialize: () => h,
-        defaultSerialize: () => u
-    });
-    v = a(o);
-    var c = y.default;
-    var l = (t, e = true) => {
-        if (t === void 0 || t === null) {
-            return "null";
-        }
-        if (typeof t === "string") {
-            return JSON.stringify(e && t.startsWith(":") ? `:${t}` : t);
-        }
-        if (c.Buffer.isBuffer(t)) {
-            return JSON.stringify(`:base64:${t.toString("base64")}`);
-        }
-        if (t?.toJSON) {
-            t = t.toJSON();
-        }
-        if (typeof t === "object") {
-            let s = "";
-            const i = Array.isArray(t);
-            s = i ? "[" : "{";
-            let r = true;
-            for (const n in t) {
-                const a = typeof t[n] === "function" || !i && t[n] === void 0;
-                if (!Object.hasOwn(t, n) || a) {
-                    continue;
-                }
-                if (!r) {
-                    s += ",";
-                }
-                r = false;
-                if (i) {
-                    s += l(t[n], e);
-                } else if (t[n] !== void 0) {
-                    s += `${l(n, false)}:${l(t[n], e)}`;
-                }
-            }
-            s += i ? "]" : "}";
-            return s;
-        }
-        return JSON.stringify(t);
-    };
-    var u = t => l(t, true);
-    var h = t => JSON.parse(t, (t, e) => {
-        if (typeof e === "string") {
-            if (e.startsWith(":base64:")) {
-                return c.Buffer.from(e.slice(8), "base64");
-            }
-            return e.startsWith(":") ? e.slice(1) : e;
-        }
-        return e;
-    });
-    return v;
-}
-
-var _ = t => {
-    const e = Math.min(2 ** t * 100, 2e3);
-    const s = (Math.random() - .5) * 100;
-    return e + s;
-};
-
-var O = class extends s.Hookified {
-    _client=e.dist.createClient();
-    _namespace;
-    _keyPrefixSeparator="::";
-    _clearBatchSize=1e3;
-    _useUnlink=true;
-    _noNamespaceAffectsAll=false;
-    _throwOnConnectError=true;
-    _throwErrors=false;
-    _connectionTimeout;
-    constructor(t, s) {
-        super();
-        const i = {
-            reconnectStrategy: _
-        };
-        if (t) {
-            if (typeof t === "string") {
-                this._client = e.dist.createClient({
-                    url: t,
-                    socket: i
-                });
-            } else if (t.connect !== void 0) {
-                this._client = this.isClientCluster(t) ? t : t;
-            } else if (t instanceof Object) {
-                this._client = t.rootNodes === void 0 ? e.dist.createClient(t) : e.dist.createCluster(t);
-            }
-        }
-        this.setOptions(s);
-        this.initClient();
-    }
-    get client() {
-        return this._client;
-    }
-    set client(t) {
-        this._client = t;
-        this.initClient();
-    }
-    get opts() {
-        let t = "redis://localhost:6379";
-        if (this._client.options) {
-            const e = this._client.options?.url;
-            if (e) {
-                t = e;
-            }
-        }
-        const e = {
-            namespace: this._namespace,
-            keyPrefixSeparator: this._keyPrefixSeparator,
-            clearBatchSize: this._clearBatchSize,
-            noNamespaceAffectsAll: this._noNamespaceAffectsAll,
-            useUnlink: this._useUnlink,
-            throwOnConnectError: this._throwOnConnectError,
-            throwErrors: this._throwErrors,
-            connectionTimeout: this._connectionTimeout,
-            dialect: "redis",
-            url: t
-        };
-        return e;
-    }
-    set opts(t) {
-        this.setOptions(t);
-    }
-    get namespace() {
-        return this._namespace;
-    }
-    set namespace(t) {
-        this._namespace = t;
-    }
-    get keyPrefixSeparator() {
-        return this._keyPrefixSeparator;
-    }
-    set keyPrefixSeparator(t) {
-        this._keyPrefixSeparator = t;
-    }
-    get clearBatchSize() {
-        return this._clearBatchSize;
-    }
-    set clearBatchSize(t) {
-        if (t > 0) {
-            this._clearBatchSize = t;
-        } else {
-            this.emit("error", "clearBatchSize must be greater than 0");
-        }
-    }
-    get useUnlink() {
-        return this._useUnlink;
-    }
-    set useUnlink(t) {
-        this._useUnlink = t;
-    }
-    get noNamespaceAffectsAll() {
-        return this._noNamespaceAffectsAll;
-    }
-    set noNamespaceAffectsAll(t) {
-        this._noNamespaceAffectsAll = t;
-    }
-    get throwOnConnectError() {
-        return this._throwOnConnectError;
-    }
-    set throwOnConnectError(t) {
-        this._throwOnConnectError = t;
-    }
-    get throwErrors() {
-        return this._throwErrors;
-    }
-    set throwErrors(t) {
-        this._throwErrors = t;
-    }
-    get connectionTimeout() {
-        return this._connectionTimeout;
-    }
-    set connectionTimeout(t) {
-        this._connectionTimeout = t;
-    }
-    async getClient() {
-        if (this._client.isOpen) {
-            return this._client;
-        }
-        try {
-            if (this._connectionTimeout === void 0) {
-                await this._client.connect();
-            } else {
-                await Promise.race([ this._client.connect(), this.createTimeoutPromise(this._connectionTimeout) ]);
-            }
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwOnConnectError) {
-                throw new Error("Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.");
-            }
-            await this.disconnect(true);
-        }
-        this.initClient();
-        return this._client;
-    }
-    async set(t, e, s) {
-        const i = await this.getClient();
-        try {
-            t = this.createKeyPrefix(t, this._namespace);
-            if (s) {
-                await i.set(t, e, {
-                    PX: s
-                });
-            } else {
-                await i.set(t, e);
-            }
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-        }
-    }
-    async setMany(t) {
-        const e = await this.getClient();
-        try {
-            const s = e.multi();
-            for (const {key: e, value: i, ttl: r} of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                if (r) {
-                    s.set(t, i, {
-                        PX: r
-                    });
-                } else {
-                    s.set(t, i);
-                }
-            }
-            await s.exec();
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-        }
-    }
-    async has(t) {
-        const e = await this.getClient();
-        try {
-            t = this.createKeyPrefix(t, this._namespace);
-            const s = await e.exists(t);
-            return s === 1;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-            return false;
-        }
-    }
-    async hasMany(t) {
-        const e = await this.getClient();
-        try {
-            const s = e.multi();
-            for (const e of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                s.exists(t);
-            }
-            const i = await s.exec();
-            return i.map(t => t === 1);
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
-            }
-            return Array.from({
-                length: t.length
-            }).fill(false);
-        }
-    }
-    async get(t) {
-        const e = await this.getClient();
-        try {
-            t = this.createKeyPrefix(t, this._namespace);
-            const s = await e.get(t);
-            if (s === null) {
-                return void 0;
-            }
-            return s;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-            return void 0;
-        }
-    }
-    async getMany(t) {
-        if (t.length === 0) {
-            return [];
-        }
-        t = t.map(t => this.createKeyPrefix(t, this._namespace));
-        try {
-            const e = await this.mget(t);
-            return e;
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
-            }
-            return Array.from({
-                length: t.length
-            }).fill(void 0);
-        }
-    }
-    async delete(t) {
-        const e = await this.getClient();
-        try {
-            t = this.createKeyPrefix(t, this._namespace);
-            let s = 0;
-            s = await (this._useUnlink ? e.unlink(t) : e.del(t));
-            return s > 0;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-            return false;
-        }
-    }
-    async deleteMany(t) {
-        let e = false;
-        const s = await this.getClient();
-        try {
-            const i = s.multi();
-            for (const e of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                if (this._useUnlink) {
-                    i.unlink(t);
-                } else {
-                    i.del(t);
-                }
-            }
-            const r = await i.exec();
-            for (const t of r) {
-                if (typeof t === "number" && t > 0) {
-                    e = true;
-                }
-            }
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-        }
-        return e;
-    }
-    async disconnect(t) {
-        if (this._client.isOpen) {
-            await (t ? this._client.disconnect() : this._client.quit());
-        }
-    }
-    createKeyPrefix(t, e) {
-        if (e) {
-            return `${e}${this._keyPrefixSeparator}${t}`;
-        }
-        return t;
-    }
-    getKeyWithoutPrefix(t, e) {
-        if (e) {
-            return t.replace(`${e}${this._keyPrefixSeparator}`, "");
-        }
-        return t;
-    }
-    isCluster() {
-        return this.isClientCluster(this._client);
-    }
-    async getMasterNodes() {
-        if (this.isCluster()) {
-            const t = await this.getClient();
-            return Promise.all(t.masters.map(async e => t.nodeClient(e)));
-        }
-        return [ await this.getClient() ];
-    }
-    async* iterator(t) {
-        const e = await this.getMasterNodes();
-        for (const s of e) {
-            const e = t ? `${t}${this._keyPrefixSeparator}*` : "*";
-            let i = "0";
-            do {
-                const r = await s.scan(Number.parseInt(i, 10), {
-                    MATCH: e,
-                    TYPE: "string"
-                });
-                i = r.cursor.toString();
-                let {keys: n} = r;
-                if (!t && !this._noNamespaceAffectsAll) {
-                    n = n.filter(t => !t.includes(this._keyPrefixSeparator));
-                }
-                if (n.length > 0) {
-                    const e = await this.mget(n);
-                    for (const s of n.keys()) {
-                        const i = this.getKeyWithoutPrefix(n[s], t);
-                        const r = e[s];
-                        yield [ i, r ];
-                    }
-                }
-            } while (i !== "0");
-        }
-    }
-    async clear() {
-        try {
-            const t = await this.getMasterNodes();
-            await Promise.all(t.map(async t => {
-                if (!this._namespace && this._noNamespaceAffectsAll) {
-                    await t.flushDb();
-                    return;
-                }
-                let e = "0";
-                const s = this._clearBatchSize;
-                const i = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
-                const r = [];
-                do {
-                    const n = await t.scan(Number.parseInt(e, 10), {
-                        MATCH: i,
-                        COUNT: s,
-                        TYPE: "string"
-                    });
-                    e = n.cursor.toString();
-                    let {keys: a} = n;
-                    if (a.length === 0) {
-                        continue;
-                    }
-                    if (!this._namespace) {
-                        a = a.filter(t => !t.includes(this._keyPrefixSeparator));
-                    }
-                    r.push(this.clearWithClusterSupport(a));
-                } while (e !== "0");
-                await Promise.all(r);
-            }));
-        } catch (t) {
-            this.emit("error", t);
-        }
-    }
-    async mget(t) {
-        const e = this.getSlotMap(t);
-        const s = new Map;
-        await Promise.all(Array.from(e.entries(), async ([t, e]) => {
-            const i = await this.getSlotMaster(t);
-            const r = await i.mGet(e);
-            for (const [t, i] of r.entries()) {
-                s.set(e[t], i ?? void 0);
-            }
-        }));
-        return t.map(t => s.get(t));
-    }
-    async clearWithClusterSupport(t) {
-        if (t.length > 0) {
-            const e = this.getSlotMap(t);
-            await Promise.all(Array.from(e.entries(), async ([t, e]) => {
-                const s = await this.getSlotMaster(t);
-                return this._useUnlink ? s.unlink(e) : s.del(e);
-            }));
-        }
-    }
-    async getSlotMaster(t) {
-        const e = await this.getClient();
-        if (this.isCluster()) {
-            const s = e;
-            const i = s.slots[t].master;
-            return s.nodeClient(i);
-        }
-        return e;
-    }
-    getSlotMap(t) {
-        const e = new Map;
-        if (this.isCluster()) {
-            for (const s of t) {
-                const t = r.calculateSlot(s);
-                const i = e.get(t) ?? [];
-                i.push(s);
-                e.set(t, i);
-            }
-        } else {
-            e.set(0, t);
-        }
-        return e;
-    }
-    isClientCluster(t) {
-        if (t.options === void 0 && t.scan === void 0) {
-            return true;
-        }
-        return false;
-    }
-    setOptions(t) {
-        if (!t) {
-            return;
-        }
-        if (t.namespace) {
-            this._namespace = t.namespace;
-        }
-        if (t.keyPrefixSeparator !== void 0) {
-            this._keyPrefixSeparator = t.keyPrefixSeparator;
-        }
-        if (t.clearBatchSize !== void 0 && t.clearBatchSize > 0) {
-            this._clearBatchSize = t.clearBatchSize;
-        }
-        if (t.useUnlink !== void 0) {
-            this._useUnlink = t.useUnlink;
-        }
-        if (t.noNamespaceAffectsAll !== void 0) {
-            this._noNamespaceAffectsAll = t.noNamespaceAffectsAll;
-        }
-        if (t.throwOnConnectError !== void 0) {
-            this._throwOnConnectError = t.throwOnConnectError;
-        }
-        if (t.throwErrors !== void 0) {
-            this._throwErrors = t.throwErrors;
-        }
-        if (t.connectionTimeout !== void 0) {
-            this._connectionTimeout = t.connectionTimeout;
-        }
-    }
-    initClient() {
-        this._client.on("connect", () => {
-            this.emit("connect", this._client);
-        });
-        this._client.on("disconnect", () => {
-            this.emit("disconnect", this._client);
-        });
-        this._client.on("reconnecting", t => {
-            this.emit("reconnecting", t);
-        });
-    }
-    async createTimeoutPromise(t) {
-        return new Promise((e, s) => setTimeout(() => {
-            s(new Error(`Redis timed out after ${t}ms`));
-        }, t));
-    }
-};
-
-const T = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get Keyv() {
-        return i.Keyv;
-    },
-    createClient: e.dist.createClient,
-    createCluster: e.dist.createCluster,
-    get default() {
-        return O;
-    },
-    get defaultReconnectStrategy() {
-        return _;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
+const n = e.EventListenerTypes;
 
-var k = class extends p.default {
-    ttlSupport=true;
-    namespace;
-    client;
-    opts;
-    constructor(t, e) {
-        super();
-        e = {
-            ...typeof t === "string" ? {
-                uri: t
-            } : t,
-            ...e
-        };
-        if (e.uri && e.url === void 0) {
-            e.url = e.uri;
-        }
-        if (t === void 0) {
-            t = "localhost:11211";
-            e.url = e.uri = t;
-        }
-        this.opts = e;
-        this.client = d.default.Client.create(t, e);
-    }
-    _getNamespace() {
-        return `namespace:${this.namespace}`;
-    }
-    async get(t) {
-        return new Promise((e, s) => {
-            this.client.get(this.formatKey(t), (t, i) => {
-                if (t) {
-                    this.emit("error", t);
-                    s(t);
-                } else {
-                    let t;
-                    if (i === null) {
-                        t = {
-                            value: void 0,
-                            expires: 0
-                        };
-                    } else {
-                        t = this.opts.deserialize ? this.opts.deserialize(i) : exports.defaultDeserialize(i);
-                    }
-                    e(t);
-                }
-            });
-        });
-    }
-    async getMany(t) {
-        const e = [];
-        for (const s of t) {
-            e.push(this.get(s));
-        }
-        return Promise.allSettled(e).then(t => {
-            const e = [];
-            for (const s of t) {
-                e.push(s.value);
-            }
-            return e;
-        });
-    }
-    async set(t, e, s) {
-        const i = {};
-        if (s !== void 0) {
-            i.expires = i.ttl = Math.floor(s / 1e3);
-        }
-        await this.client.set(this.formatKey(t), e, i);
-    }
-    async delete(t) {
-        return new Promise((e, s) => {
-            this.client.delete(this.formatKey(t), (t, i) => {
-                if (t) {
-                    this.emit("error", t);
-                    s(t);
-                } else {
-                    e(Boolean(i));
-                }
-            });
-        });
-    }
-    async deleteMany(t) {
-        const e = t.map(async t => this.delete(t));
-        const s = await Promise.allSettled(e);
-        return s.every(t => t.value === true);
-    }
-    async clear() {
-        return new Promise((t, e) => {
-            this.client.flush(s => {
-                if (s) {
-                    this.emit("error", s);
-                    e(s);
-                } else {
-                    t(void 0);
-                }
-            });
+function s() {
+    return function(e, t) {
+        (0, r.getMetadataArgsStorage)().entityListeners.push({
+            target: e.constructor,
+            propertyName: t,
+            type: n.EventListenerTypes.AFTER_INSERT
         });
-    }
-    formatKey(t) {
-        let e = t;
-        if (this.namespace) {
-            e = this.namespace.trim() + ":" + t.trim();
-        }
-        return e;
-    }
-    async has(t) {
-        return new Promise(e => {
-            this.client.get(this.formatKey(t), (t, s) => {
-                if (t) {
-                    e(false);
-                } else {
-                    e(s !== null);
-                }
-            });
-        });
-    }
-};
-
-const $ = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvMemcache() {
-        return k;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var C = new Set([ "url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect", "db" ]);
-
-var N = class extends p.default {
-    ttlSupport=false;
-    opts;
-    connect;
-    namespace;
-    constructor(t, e) {
-        super();
-        t ??= {};
-        if (typeof t === "string") {
-            t = {
-                url: t
-            };
-        }
-        if (t.uri) {
-            t = {
-                url: t.uri,
-                ...t
-            };
-        }
-        this.opts = {
-            url: "mongodb://127.0.0.1:27017",
-            collection: "keyv",
-            ...t,
-            ...e
-        };
-        delete this.opts.emitErrors;
-        const s = Object.fromEntries(Object.entries(this.opts).filter(([t]) => !C.has(t)));
-        this.opts = Object.fromEntries(Object.entries(this.opts).filter(([t]) => C.has(t)));
-        this.connect = new Promise(async (t, e) => {
-            try {
-                let e = "";
-                if (this.opts.url) {
-                    e = this.opts.url;
-                }
-                const i = new o.MongoClient(e, s);
-                await i.connect();
-                const r = i.db(this.opts.db);
-                if (this.opts.useGridFS) {
-                    const e = new o.GridFSBucket(r, {
-                        readPreference: this.opts.readPreference,
-                        bucketName: this.opts.collection
-                    });
-                    const s = r.collection(`${this.opts.collection}.files`);
-                    await s.createIndex({
-                        uploadDate: -1
-                    });
-                    await s.createIndex({
-                        "metadata.expiresAt": 1
-                    });
-                    await s.createIndex({
-                        "metadata.lastAccessed": 1
-                    });
-                    await s.createIndex({
-                        "metadata.filename": 1
-                    });
-                    t({
-                        bucket: e,
-                        store: s,
-                        db: r,
-                        mongoClient: i
-                    });
-                } else {
-                    let e = "keyv";
-                    if (this.opts.collection) {
-                        e = this.opts.collection;
-                    }
-                    const s = r.collection(e);
-                    await s.createIndex({
-                        key: 1
-                    }, {
-                        unique: true,
-                        background: true
-                    });
-                    await s.createIndex({
-                        expiresAt: 1
-                    }, {
-                        expireAfterSeconds: 0,
-                        background: true
-                    });
-                    t({
-                        store: s,
-                        mongoClient: i
-                    });
-                }
-            } catch (t) {
-                this.emit("error", t);
-            }
-        });
-    }
-    async get(e) {
-        const s = await this.connect;
-        if (this.opts.useGridFS) {
-            await s.store.updateOne({
-                filename: String(e)
-            }, {
-                $set: {
-                    "metadata.lastAccessed": new Date
-                }
-            });
-            const i = s.bucket.openDownloadStreamByName(e);
-            return new Promise(e => {
-                const s = [];
-                i.on("error", () => {
-                    e(void 0);
-                });
-                i.on("end", () => {
-                    const i = t.Buffer.concat(s).toString("utf8");
-                    e(i);
-                });
-                i.on("data", t => {
-                    s.push(t);
-                });
-            });
-        }
-        const i = await s.store.findOne({
-            key: {
-                $eq: e
-            }
-        });
-        if (!i) {
-            return void 0;
-        }
-        return i.value;
-    }
-    async getMany(t) {
-        if (this.opts.useGridFS) {
-            const e = [];
-            for (const s of t) {
-                e.push(this.get(s));
-            }
-            const s = await Promise.allSettled(e);
-            const i = [];
-            for (const t of s) {
-                i.push(t.value);
-            }
-            return i;
-        }
-        const e = await this.connect;
-        const s = await e.store.s.db.collection(this.opts.collection).find({
-            key: {
-                $in: t
-            }
-        }).project({
-            _id: 0,
-            value: 1,
-            key: 1
-        }).toArray();
-        const i = [ ...t ];
-        let r = 0;
-        for (const e of t) {
-            const t = s.findIndex(t => t.key === e);
-            i[r] = t > -1 ? s[t].value : void 0;
-            r++;
-        }
-        return i;
-    }
-    async set(t, e, s) {
-        const i = typeof s === "number" ? new Date(Date.now() + s) : null;
-        if (this.opts.useGridFS) {
-            const s = await this.connect;
-            const r = s.bucket.openUploadStream(t, {
-                metadata: {
-                    expiresAt: i,
-                    lastAccessed: new Date
-                }
-            });
-            return new Promise(t => {
-                r.on("finish", () => {
-                    t(r);
-                });
-                r.end(e);
-            });
-        }
-        const r = await this.connect;
-        await r.store.updateOne({
-            key: {
-                $eq: t
-            }
-        }, {
-            $set: {
-                key: t,
-                value: e,
-                expiresAt: i
-            }
-        }, {
-            upsert: true
-        });
-    }
-    async delete(t) {
-        if (typeof t !== "string") {
-            return false;
-        }
-        const e = await this.connect;
-        if (this.opts.useGridFS) {
-            try {
-                const s = e.db;
-                const i = new o.GridFSBucket(s, {
-                    bucketName: this.opts.collection
-                });
-                const r = await i.find({
-                    filename: t
-                }).toArray();
-                await e.bucket.delete(r[0]._id);
-                return true;
-            } catch {
-                return false;
-            }
-        }
-        const s = await e.store.deleteOne({
-            key: {
-                $eq: t
-            }
-        });
-        return s.deletedCount > 0;
-    }
-    async deleteMany(t) {
-        const e = await this.connect;
-        if (this.opts.useGridFS) {
-            const s = e.db;
-            const i = new o.GridFSBucket(s, {
-                bucketName: this.opts.collection
-            });
-            const r = await i.find({
-                filename: {
-                    $in: t
-                }
-            }).toArray();
-            if (r.length === 0) {
-                return false;
-            }
-            await Promise.all(r.map(async t => e.bucket.delete(t._id)));
-            return true;
-        }
-        const s = await e.store.deleteMany({
-            key: {
-                $in: t
-            }
-        });
-        return s.deletedCount > 0;
-    }
-    async clear() {
-        const t = await this.connect;
-        if (this.opts.useGridFS) {
-            try {
-                await t.bucket.drop();
-            } catch (t) {
-                if (!(t instanceof o.MongoServerError && t.code === 26)) {
-                    throw t;
-                }
-            }
-        }
-        await t.store.deleteMany({
-            key: {
-                $regex: this.namespace ? `^${this.namespace}:*` : ""
-            }
-        });
-    }
-    async clearExpired() {
-        if (!this.opts.useGridFS) {
-            return false;
-        }
-        return this.connect.then(async t => {
-            const e = t.db;
-            const s = new o.GridFSBucket(e, {
-                bucketName: this.opts.collection
-            });
-            return s.find({
-                "metadata.expiresAt": {
-                    $lte: new Date(Date.now())
-                }
-            }).toArray().then(async e => Promise.all(e.map(async e => t.bucket.delete(e._id))).then(() => true));
-        });
-    }
-    async clearUnusedFor(t) {
-        if (!this.opts.useGridFS) {
-            return false;
-        }
-        const e = await this.connect;
-        const s = e.db;
-        const i = new o.GridFSBucket(s, {
-            bucketName: this.opts.collection
-        });
-        const r = await i.find({
-            "metadata.lastAccessed": {
-                $lte: new Date(Date.now() - t * 1e3)
-            }
-        }).toArray();
-        await Promise.all(r.map(async t => e.bucket.delete(t._id)));
-        return true;
-    }
-    async* iterator(t) {
-        const e = await this.connect;
-        const s = new RegExp(`^${t ? t + ":" : ".*"}`);
-        const i = this.opts.useGridFS ? e.store.find({
-            filename: s
-        }).map(async t => [ t.filename, await this.get(t.filename) ]) : e.store.find({
-            key: s
-        }).map(t => [ t.key, t.value ]);
-        yield* i;
-    }
-    async has(t) {
-        const e = await this.connect;
-        const s = {
-            [this.opts.useGridFS ? "filename" : "key"]: {
-                $eq: t
-            }
-        };
-        const i = await e.store.count(s);
-        return i !== 0;
-    }
-    async disconnect() {
-        const t = await this.connect;
-        await t.mongoClient.close();
-    }
-};
-
-const x = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvMongo() {
-        return N;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var R = t => {
-    const e = String(t).replace(/[^a-zA-Z0-9_]/g, "");
-    if (e.length === 0) {
-        throw new Error("Invalid table name: must contain alphanumeric characters");
-    }
-    return /^[a-zA-Z]/.test(e) ? e : `_${e}`;
-};
-
-var M = class extends p.default {
-    ttlSupport;
-    opts;
-    namespace;
-    close;
-    query;
-    constructor(t) {
-        super();
-        this.ttlSupport = false;
-        let e = {
-            dialect: "sqlite",
-            uri: "sqlite://:memory:"
-        };
-        if (typeof t === "string") {
-            e.uri = t;
-        } else {
-            e = {
-                ...e,
-                ...t
-            };
-        }
-        e.db = e.uri.replace(/^sqlite:\/\//, "");
-        e.connect = async () => new Promise((t, s) => {
-            const i = new m.default.Database(e.db, r => {
-                if (r) {
-                    s(r);
-                } else {
-                    if (e.busyTimeout) {
-                        i.configure("busyTimeout", e.busyTimeout);
-                    }
-                    t(i);
-                }
-            });
-        }).then(t => ({
-            query: c.promisify(t.all).bind(t),
-            close: c.promisify(t.close).bind(t)
-        }));
-        this.opts = {
-            table: "keyv",
-            keySize: 255,
-            ...e
-        };
-        this.opts.table = R(this.opts.table);
-        const s = Number(this.opts.keySize);
-        if (!Number.isFinite(s) || s <= 0 || s > 65535) {
-            throw new Error("Invalid keySize: must be a positive number between 1 and 65535");
-        }
-        const i = `CREATE TABLE IF NOT EXISTS ${this.opts.table}(key VARCHAR(${s}) PRIMARY KEY, value TEXT )`;
-        const r = this.opts.connect().then(async t => t.query(i).then(() => t)).catch(t => this.emit("error", t));
-        this.query = async (t, ...e) => r.then(async s => s.query(t, ...e));
-        this.close = async () => r.then(t => t.close());
-    }
-    async get(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE key = ?`;
-        const s = await this.query(e, t);
-        const i = s[0];
-        if (i === void 0) {
-            return void 0;
-        }
-        return i.value;
-    }
-    async getMany(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE key IN (SELECT value FROM json_each(?))`;
-        const s = await this.query(e, JSON.stringify(t));
-        return t.map(t => {
-            const e = s.find(e => e.key === t);
-            return e ? e.value : void 0;
-        });
-    }
-    async set(t, e) {
-        const s = `INSERT INTO ${this.opts.table} (key, value)\n\t\t\tVALUES(?, ?) \n\t\t\tON CONFLICT(key) \n\t\t\tDO UPDATE SET value=excluded.value;`;
-        return this.query(s, t, e);
-    }
-    async delete(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE key = ?`;
-        const s = `DELETE FROM ${this.opts.table} WHERE key = ?`;
-        const i = await this.query(e, t);
-        const r = i[0];
-        if (r === void 0) {
-            return false;
-        }
-        await this.query(s, t);
-        return true;
-    }
-    async deleteMany(t) {
-        const e = `DELETE FROM ${this.opts.table} WHERE key IN (SELECT value FROM json_each(?))`;
-        const s = await this.getMany(t);
-        if (s.every(t => t === void 0)) {
-            return false;
-        }
-        await this.query(e, JSON.stringify(t));
-        return true;
-    }
-    async clear() {
-        const t = `DELETE FROM ${this.opts.table} WHERE key LIKE ?`;
-        await this.query(t, this.namespace ? `${this.namespace}:%` : "%");
-    }
-    async* iterator(t) {
-        const e = Number.parseInt(this.opts.iterationLimit, 10) || 10;
-        async function* s(i, r, n) {
-            const a = `SELECT * FROM ${r.table} WHERE key LIKE ? LIMIT ? OFFSET ?`;
-            const o = await n(a, [ `${t ? t + ":" : ""}%`, e, i ]);
-            const c = [ ...o ];
-            if (c.length === 0) {
-                return;
-            }
-            for (const t of c) {
-                i += 1;
-                yield [ t.key, t.value ];
-            }
-            yield* s(i, r, n);
-        }
-        yield* s(0, this.opts, this.query);
-    }
-    async has(t) {
-        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.table} WHERE key = ? )`;
-        const s = await this.query(e, t);
-        return Object.values(s[0])[0] === 1;
-    }
-    async disconnect() {
-        await this.close();
-    }
-};
-
-const A = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvSqlite() {
-        return M;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var P;
-
-var q;
-
-var I = (t, e = {}) => {
-    if (q !== t) {
-        P = void 0;
-        q = t;
-    }
-    P ??= new E.default.Pool({
-        connectionString: t,
-        ...e
-    });
-    return P;
-};
-
-var F = async () => {
-    await (P?.end());
-    q = void 0;
-};
-
-var L = class extends p.default {
-    ttlSupport;
-    opts;
-    query;
-    namespace;
-    constructor(t) {
-        super();
-        this.ttlSupport = false;
-        if (typeof t === "string") {
-            const e = t;
-            t = {
-                dialect: "postgres",
-                uri: e
-            };
-        } else {
-            t = {
-                dialect: "postgres",
-                uri: "postgresql://localhost:5432",
-                ...t
-            };
-        }
-        this.opts = {
-            table: "keyv",
-            schema: "public",
-            keySize: 255,
-            ...t
-        };
-        let e = `CREATE${this.opts.useUnloggedTable ? " UNLOGGED " : " "}TABLE IF NOT EXISTS ${this.opts.schema}.${this.opts.table}(key VARCHAR(${Number(this.opts.keySize)}) PRIMARY KEY, value TEXT )`;
-        if (this.opts.schema !== "public") {
-            e = `CREATE SCHEMA IF NOT EXISTS ${this.opts.schema}; ${e}`;
-        }
-        const s = this.connect().then(async t => {
-            try {
-                await t(e);
-            } catch (e) {
-                if (e.code !== "23505") {
-                    this.emit("error", e);
-                }
-                return t;
-            }
-            return t;
-        }).catch(t => this.emit("error", t));
-        this.query = async (t, e) => s.then(s => s(t, e));
-    }
-    async get(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1`;
-        const s = await this.query(e, [ t ]);
-        const i = s[0];
-        return i === void 0 ? void 0 : i.value;
-    }
-    async getMany(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = ANY($1)`;
-        const s = await this.query(e, [ t ]);
-        const i = new Map(s.map(t => [ t.key, t ]));
-        return t.map(t => i.get(t)?.value);
-    }
-    async set(t, e) {
-        const s = `INSERT INTO ${this.opts.schema}.${this.opts.table} (key, value)\n      VALUES($1, $2) \n      ON CONFLICT(key) \n      DO UPDATE SET value=excluded.value;`;
-        await this.query(s, [ t, e ]);
-    }
-    async setMany(t) {
-        const e = [];
-        const s = [];
-        for (const {key: i, value: r} of t) {
-            e.push(i);
-            s.push(r);
-        }
-        const i = `INSERT INTO ${this.opts.schema}.${this.opts.table} (key, value)\n      SELECT * FROM UNNEST($1::text[], $2::text[])\n      ON CONFLICT(key)\n      DO UPDATE SET value=excluded.value;`;
-        await this.query(i, [ e, s ]);
-    }
-    async delete(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1`;
-        const s = `DELETE FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1`;
-        const i = await this.query(e, [ t ]);
-        if (i[0] === void 0) {
-            return false;
-        }
-        await this.query(s, [ t ]);
-        return true;
-    }
-    async deleteMany(t) {
-        const e = `SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = ANY($1)`;
-        const s = `DELETE FROM ${this.opts.schema}.${this.opts.table} WHERE key = ANY($1)`;
-        const i = await this.query(e, [ t ]);
-        if (i[0] === void 0) {
-            return false;
-        }
-        await this.query(s, [ t ]);
-        return true;
-    }
-    async clear() {
-        const t = `DELETE FROM ${this.opts.schema}.${this.opts.table} WHERE key LIKE $1`;
-        await this.query(t, [ this.namespace ? `${this.namespace}:%` : "%" ]);
-    }
-    async* iterator(t) {
-        const e = Number.parseInt(String(this.opts.iterationLimit), 10) || 10;
-        async function* s(i, r, n) {
-            const a = `SELECT * FROM ${r.schema}.${r.table} WHERE key LIKE $1 LIMIT $2 OFFSET $3`;
-            const o = await n(a, [ `${t ? t + ":" : ""}%`, e, i ]);
-            if (o.length === 0) {
-                return;
-            }
-            for (const t of o) {
-                i += 1;
-                yield [ t.key, t.value ];
-            }
-            yield* s(i, r, n);
-        }
-        yield* s(0, this.opts, this.query);
-    }
-    async has(t) {
-        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.schema}.${this.opts.table} WHERE key = $1 )`;
-        const s = await this.query(e, [ t ]);
-        return s[0].exists;
-    }
-    async connect() {
-        const t = I(this.opts.uri, this.opts);
-        return async (e, s) => {
-            const i = await t.query(e, s);
-            return i.rows;
-        };
-    }
-    async disconnect() {
-        await F();
-    }
-};
-
-const D = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvPostgres() {
-        return L;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var z;
-
-var j;
-
-var W = t => {
-    t = t.replace(/#/g, "%23");
-    const e = new URL(t);
-    const s = {
-        user: decodeURIComponent(e.username),
-        password: decodeURIComponent(e.password) || void 0,
-        host: e.hostname,
-        port: e.port ? Number.parseInt(e.port, 10) : void 0,
-        database: decodeURIComponent(e.pathname.slice(1))
     };
-    for (const t of Object.keys(s)) {
-        if (s[t] === void 0) {
-            delete s[t];
-        }
-    }
-    return s;
-};
-
-var H = (t, e = {}) => {
-    if (j !== t) {
-        z = void 0;
-        j = t;
-    }
-    const s = W(t);
-    const i = {
-        ...s,
-        ...e
-    };
-    z ??= w.default.createPool(i);
-    return z.promise();
-};
-
-var U = () => {
-    if (z) {
-        z.end();
-    }
-    j = void 0;
-};
-
-var K = new Set([ "adapter", "compression", "connect", "dialect", "keySize", "table", "ttl", "uri" ]);
-
-var B = class extends p.default {
-    ttlSupport=false;
-    opts;
-    namespace;
-    query;
-    constructor(t) {
-        super();
-        let e = {
-            dialect: "mysql",
-            uri: "mysql://localhost"
-        };
-        if (typeof t === "string") {
-            e.uri = t;
-        } else {
-            e = {
-                ...e,
-                ...t
-            };
-        }
-        if (e.intervalExpiration !== void 0 && e.intervalExpiration > 0) {
-            this.ttlSupport = true;
-        }
-        const s = Object.fromEntries(Object.entries(e).filter(([t]) => !K.has(t)));
-        delete s.namespace;
-        delete s.serialize;
-        delete s.deserialize;
-        const i = async () => {
-            const t = H(e.uri, s);
-            return async e => {
-                const s = await t.query(e);
-                return s[0];
-            };
-        };
-        this.opts = {
-            table: "keyv",
-            keySize: 255,
-            ...e
-        };
-        const r = `CREATE TABLE IF NOT EXISTS ${this.opts.table}(id VARCHAR(${Number(this.opts.keySize)}) PRIMARY KEY, value TEXT)`;
-        const n = i().then(async t => {
-            await t(r);
-            if (this.opts.intervalExpiration !== void 0 && this.opts.intervalExpiration > 0) {
-                await t("SET GLOBAL event_scheduler = ON;");
-                await t("DROP EVENT IF EXISTS keyv_delete_expired_keys;");
-                await t(`CREATE EVENT IF NOT EXISTS keyv_delete_expired_keys ON SCHEDULE EVERY ${this.opts.intervalExpiration} SECOND\n\t\t\t\t\tDO DELETE FROM ${this.opts.table}\n\t\t\t\t\tWHERE CAST(value->'$.expires' AS UNSIGNED) BETWEEN 1 AND UNIX_TIMESTAMP(NOW(3)) * 1000;`);
-            }
-            return t;
-        }).catch(t => this.emit("error", t));
-        this.query = async t => {
-            const e = await n;
-            return e(t);
-        };
-    }
-    async get(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE id = ?`;
-        const s = w.default.format(e, [ t ]);
-        const i = await this.query(s);
-        const r = i[0];
-        return r?.value;
-    }
-    async getMany(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE id IN (?)`;
-        const s = w.default.format(e, [ t ]);
-        const i = await this.query(s);
-        const r = [];
-        for (const e of t) {
-            const t = i.findIndex(t => t.id === e);
-            r.push(t === -1 ? void 0 : i[t].value);
-        }
-        return r;
-    }
-    async set(t, e) {
-        const s = `INSERT INTO ${this.opts.table} (id, value)\n\t\t\tVALUES(?, ?)\n\t\t\tON DUPLICATE KEY UPDATE value=?;`;
-        const i = [ t, e, e ];
-        const r = w.default.format(s, i);
-        return this.query(r);
-    }
-    async delete(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE id = ?`;
-        const s = w.default.format(e, [ t ]);
-        const i = `DELETE FROM ${this.opts.table} WHERE id = ?`;
-        const r = w.default.format(i, [ t ]);
-        const n = await this.query(s);
-        const a = n[0];
-        if (a === void 0) {
-            return false;
-        }
-        await this.query(r);
-        return true;
-    }
-    async deleteMany(t) {
-        const e = `DELETE FROM ${this.opts.table} WHERE id IN (?)`;
-        const s = w.default.format(e, [ t ]);
-        const i = await this.query(s);
-        return i.affectedRows !== 0;
-    }
-    async clear() {
-        const t = `DELETE FROM ${this.opts.table} WHERE id LIKE ?`;
-        const e = w.default.format(t, [ this.namespace ? `${this.namespace}:%` : "%" ]);
-        await this.query(e);
-    }
-    async* iterator(t) {
-        const e = Number.parseInt(this.opts.iterationLimit, 10) || 10;
-        async function* s(i, r, n) {
-            const a = `SELECT * FROM ${r.table} WHERE id LIKE ? LIMIT ? OFFSET ?`;
-            const o = w.default.format(a, [ `${t ? t + ":" : ""}%`, e, i ]);
-            const c = await n(o);
-            if (c.length === 0) {
-                return;
-            }
-            for (const t of c) {
-                i += 1;
-                yield [ t.id, t.value ];
-            }
-            yield* s(i, r, n);
-        }
-        yield* s(0, this.opts, this.query);
-    }
-    async has(t) {
-        const e = `SELECT EXISTS ( SELECT * FROM ${this.opts.table} WHERE id = ? )`;
-        const s = w.default.format(e, [ t ]);
-        const i = await this.query(s);
-        return Object.values(i[0])[0] === 1;
-    }
-    async disconnect() {
-        U();
-    }
-};
-
-const G = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvMysql() {
-        return B;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-exports.index = T;
-
-exports.index$1 = $;
-
-exports.index$2 = x;
-
-exports.index$3 = A;
-
-exports.index$4 = D;
-
-exports.index$5 = G;
-
-exports.requireDist = b;
+}