lakutata 2.0.95 → 2.0.97

package/vendor/Package.internal.11.mjs

@@ -1,1589 +1,26 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-import t, { Buffer as e } from "buffer";
+/* Build Date: Mon Nov 24 2025 18:10:51 GMT+0800 (China Standard Time) */
+import { a as e, E as t } from "./Package.internal.51.mjs";
 
-import { createClient as s, createCluster as i } from "@redis/client";
+var r = {};
 
-import { H as r } from "./Package.internal.12.mjs";
-
-import { K as n } from "./Package.internal.13.mjs";
-
-import o from "cluster-key-slot";
-
-import a from "events";
-
-import c from "memjs";
-
-import { MongoClient as l, GridFSBucket as h, MongoServerError as u } from "mongodb";
-
-import { promisify as f } from "util";
-
-import y from "sqlite3";
-
-import p from "pg";
-
-import m from "mysql2";
-
-var d = (t, s = true) => {
-    if (t === void 0 || t === null) {
-        return "null";
-    }
-    if (typeof t === "string") {
-        return JSON.stringify(s && t.startsWith(":") ? `:${t}` : t);
-    }
-    if (e.isBuffer(t)) {
-        return JSON.stringify(`:base64:${t.toString("base64")}`);
-    }
-    if (t?.toJSON) {
-        t = t.toJSON();
-    }
-    if (typeof t === "object") {
-        let e = "";
-        const i = Array.isArray(t);
-        e = i ? "[" : "{";
-        let r = true;
-        for (const n in t) {
-            const o = typeof t[n] === "function" || !i && t[n] === void 0;
-            if (!Object.hasOwn(t, n) || o) {
-                continue;
-            }
-            if (!r) {
-                e += ",";
-            }
-            r = false;
-            if (i) {
-                e += d(t[n], s);
-            } else if (t[n] !== void 0) {
-                e += `${d(n, false)}:${d(t[n], s)}`;
-            }
-        }
-        e += i ? "]" : "}";
-        return e;
-    }
-    return JSON.stringify(t);
-};
-
-var E = t => d(t, true);
-
-var w = t => JSON.parse(t, (t, s) => {
-    if (typeof s === "string") {
-        if (s.startsWith(":base64:")) {
-            return e.from(s.slice(8), "base64");
-        }
-        return s.startsWith(":") ? s.slice(1) : s;
-    }
-    return s;
+Object.defineProperty(r, "__esModule", {
+    value: true
 });
 
-var S;
-
-var v;
-
-function g() {
-    if (v) return S;
-    v = 1;
-    var e = Object.defineProperty;
-    var s = Object.getOwnPropertyDescriptor;
-    var i = Object.getOwnPropertyNames;
-    var r = Object.prototype.hasOwnProperty;
-    var n = (t, s) => {
-        for (var i in s) e(t, i, {
-            get: s[i],
-            enumerable: true
-        });
-    };
-    var o = (t, n, o, a) => {
-        if (n && typeof n === "object" || typeof n === "function") {
-            for (let c of i(n)) if (!r.call(t, c) && c !== o) e(t, c, {
-                get: () => n[c],
-                enumerable: !(a = s(n, c)) || a.enumerable
-            });
-        }
-        return t;
-    };
-    var a = t => o(e({}, "__esModule", {
-        value: true
-    }), t);
-    var c = {};
-    n(c, {
-        defaultDeserialize: () => f,
-        defaultSerialize: () => u
-    });
-    S = a(c);
-    var l = t;
-    var h = (t, e = true) => {
-        if (t === void 0 || t === null) {
-            return "null";
-        }
-        if (typeof t === "string") {
-            return JSON.stringify(e && t.startsWith(":") ? `:${t}` : t);
-        }
-        if (l.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 o = typeof t[n] === "function" || !i && t[n] === void 0;
-                if (!Object.hasOwn(t, n) || o) {
-                    continue;
-                }
-                if (!r) {
-                    s += ",";
-                }
-                r = false;
-                if (i) {
-                    s += h(t[n], e);
-                } else if (t[n] !== void 0) {
-                    s += `${h(n, false)}:${h(t[n], e)}`;
-                }
-            }
-            s += i ? "]" : "}";
-            return s;
-        }
-        return JSON.stringify(t);
-    };
-    var u = t => h(t, true);
-    var f = t => JSON.parse(t, (t, e) => {
-        if (typeof e === "string") {
-            if (e.startsWith(":base64:")) {
-                return l.Buffer.from(e.slice(8), "base64");
-            }
-            return e.startsWith(":") ? e.slice(1) : e;
-        }
-        return e;
-    });
-    return S;
-}
-
-var b = t => {
-    const e = Math.min(2 ** t * 100, 2e3);
-    const s = (Math.random() - .5) * 100;
-    return e + s;
-};
+var a = r.AfterInsert = o;
 
-var _ = class extends r {
-    _client=s();
-    _namespace;
-    _keyPrefixSeparator="::";
-    _clearBatchSize=1e3;
-    _useUnlink=true;
-    _noNamespaceAffectsAll=false;
-    _throwOnConnectError=true;
-    _throwErrors=false;
-    _connectionTimeout;
-    constructor(t, e) {
-        super();
-        const r = {
-            reconnectStrategy: b
-        };
-        if (t) {
-            if (typeof t === "string") {
-                this._client = s({
-                    url: t,
-                    socket: r
-                });
-            } else if (t.connect !== void 0) {
-                this._client = this.isClientCluster(t) ? t : t;
-            } else if (t instanceof Object) {
-                this._client = t.rootNodes === void 0 ? s(t) : i(t);
-            }
-        }
-        this.setOptions(e);
-        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: o} = n;
-                    if (o.length === 0) {
-                        continue;
-                    }
-                    if (!this._namespace) {
-                        o = o.filter(t => !t.includes(this._keyPrefixSeparator));
-                    }
-                    r.push(this.clearWithClusterSupport(o));
-                } 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 = o(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 n = e();
 
-const O = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get Keyv() {
-        return n;
-    },
-    createClient: s,
-    createCluster: i,
-    get default() {
-        return _;
-    },
-    get defaultReconnectStrategy() {
-        return b;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
+const s = t;
 
-var T = class extends a {
-    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 = c.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) : w(i);
-                    }
-                    e(t);
-                }
-            });
+function o() {
+    return function(e, t) {
+        (0, n.getMetadataArgsStorage)().entityListeners.push({
+            target: e.constructor,
+            propertyName: t,
+            type: s.EventListenerTypes.AFTER_INSERT
         });
-    }
-    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);
-                }
-            });
-        });
-    }
-    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 k = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvMemcache() {
-        return T;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var $ = new Set([ "url", "collection", "namespace", "serialize", "deserialize", "uri", "useGridFS", "dialect", "db" ]);
-
-var C = class extends a {
-    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]) => !$.has(t)));
-        this.opts = Object.fromEntries(Object.entries(this.opts).filter(([t]) => $.has(t)));
-        this.connect = new Promise(async (t, e) => {
-            try {
-                let e = "";
-                if (this.opts.url) {
-                    e = this.opts.url;
-                }
-                const i = new l(e, s);
-                await i.connect();
-                const r = i.db(this.opts.db);
-                if (this.opts.useGridFS) {
-                    const e = new h(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(t) {
-        const s = await this.connect;
-        if (this.opts.useGridFS) {
-            await s.store.updateOne({
-                filename: String(t)
-            }, {
-                $set: {
-                    "metadata.lastAccessed": new Date
-                }
-            });
-            const i = s.bucket.openDownloadStreamByName(t);
-            return new Promise(t => {
-                const s = [];
-                i.on("error", () => {
-                    t(void 0);
-                });
-                i.on("end", () => {
-                    const i = e.concat(s).toString("utf8");
-                    t(i);
-                });
-                i.on("data", t => {
-                    s.push(t);
-                });
-            });
-        }
-        const i = await s.store.findOne({
-            key: {
-                $eq: t
-            }
-        });
-        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 h(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 h(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 u && 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 h(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 h(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 N = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvMongo() {
-        return C;
-    }
-}, 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 A = class extends a {
-    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 y.Database(e.db, r => {
-                if (r) {
-                    s(r);
-                } else {
-                    if (e.busyTimeout) {
-                        i.configure("busyTimeout", e.busyTimeout);
-                    }
-                    t(i);
-                }
-            });
-        }).then(t => ({
-            query: f(t.all).bind(t),
-            close: f(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 o = `SELECT * FROM ${r.table} WHERE key LIKE ? LIMIT ? OFFSET ?`;
-            const a = await n(o, [ `${t ? t + ":" : ""}%`, e, i ]);
-            const c = [ ...a ];
-            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 M = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvSqlite() {
-        return A;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var P;
-
-var x;
-
-var I = (t, e = {}) => {
-    if (x !== t) {
-        P = void 0;
-        x = t;
-    }
-    P ??= new p.Pool({
-        connectionString: t,
-        ...e
-    });
-    return P;
-};
-
-var L = async () => {
-    await (P?.end());
-    x = void 0;
-};
-
-var F = class extends a {
-    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 o = `SELECT * FROM ${r.schema}.${r.table} WHERE key LIKE $1 LIMIT $2 OFFSET $3`;
-            const a = await n(o, [ `${t ? t + ":" : ""}%`, e, i ]);
-            if (a.length === 0) {
-                return;
-            }
-            for (const t of a) {
-                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 L();
-    }
-};
-
-const q = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvPostgres() {
-        return F;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
-
-var D;
-
-var W;
-
-var j = 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 z = (t, e = {}) => {
-    if (W !== t) {
-        D = void 0;
-        W = t;
-    }
-    const s = j(t);
-    const i = {
-        ...s,
-        ...e
-    };
-    D ??= m.createPool(i);
-    return D.promise();
-};
-
-var H = () => {
-    if (D) {
-        D.end();
-    }
-    W = void 0;
-};
-
-var U = new Set([ "adapter", "compression", "connect", "dialect", "keySize", "table", "ttl", "uri" ]);
-
-var K = class extends a {
-    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]) => !U.has(t)));
-        delete s.namespace;
-        delete s.serialize;
-        delete s.deserialize;
-        const i = async () => {
-            const t = z(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 = m.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 = m.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 = m.format(s, i);
-        return this.query(r);
-    }
-    async delete(t) {
-        const e = `SELECT * FROM ${this.opts.table} WHERE id = ?`;
-        const s = m.format(e, [ t ]);
-        const i = `DELETE FROM ${this.opts.table} WHERE id = ?`;
-        const r = m.format(i, [ t ]);
-        const n = await this.query(s);
-        const o = n[0];
-        if (o === 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 = m.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 = m.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 o = `SELECT * FROM ${r.table} WHERE id LIKE ? LIMIT ? OFFSET ?`;
-            const a = m.format(o, [ `${t ? t + ":" : ""}%`, e, i ]);
-            const c = await n(a);
-            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 = m.format(e, [ t ]);
-        const i = await this.query(s);
-        return Object.values(i[0])[0] === 1;
-    }
-    async disconnect() {
-        H();
-    }
-};
-
-const B = Object.freeze(Object.defineProperty({
-    __proto__: null,
-    get KeyvMysql() {
-        return K;
-    }
-}, Symbol.toStringTag, {
-    value: "Module"
-}));
+}
 
-export { w as a, k as b, N as c, E as d, M as e, q as f, B as g, O as i, g as r };
+export { a as A };