lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.14.cjs

@@ -1,990 +1,795 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const t = require("events");
+const t = require("./Package.internal.11.cjs");
 
-const e = require("fs");
-
-const r = require("./Package.internal.15.cjs");
-
-const s = require("path");
-
-const i = require("./Package.internal.16.cjs");
-
-const n = require("stream");
-
-const o = t => t && t.__esModule ? t : {
-    default: t
-};
-
-const a = o(t);
-
-const u = o(e);
-
-const c = o(s);
-
-const l = o(n);
-
-exports.out$1 = {};
-
-var d = {};
-
-var h = {};
-
-var _ = {};
-
-var f = {};
-
-exports.out = {};
-
-var S = {};
-
-Object.defineProperty(S, "__esModule", {
-    value: true
-});
-
-S.read = void 0;
-
-function p(t, e, r) {
-    e.fs.lstat(t, (s, i) => {
-        if (s !== null) {
-            y(r, s);
-            return;
-        }
-        if (!i.isSymbolicLink() || !e.followSymbolicLink) {
-            m(r, i);
-            return;
+var e = class {
+    _eventListeners;
+    _maxListeners;
+    constructor() {
+        this._eventListeners = new Map;
+        this._maxListeners = 100;
+    }
+    maxListeners() {
+        return this._maxListeners;
+    }
+    addListener(t, e) {
+        this.on(t, e);
+    }
+    on(t, e) {
+        if (!this._eventListeners.has(t)) {
+            this._eventListeners.set(t, []);
         }
-        e.fs.stat(t, (t, s) => {
-            if (t !== null) {
-                if (e.throwErrorOnBrokenSymbolicLink) {
-                    y(r, t);
-                    return;
-                }
-                m(r, i);
-                return;
-            }
-            if (e.markSymbolicLink) {
-                s.isSymbolicLink = () => true;
+        const s = this._eventListeners.get(t);
+        if (s) {
+            if (s.length >= this._maxListeners) {
+                console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${t} listeners added. Use setMaxListeners() to increase limit.`);
             }
-            m(r, s);
-        });
-    });
-}
-
-S.read = p;
-
-function y(t, e) {
-    t(e);
-}
-
-function m(t, e) {
-    t(null, e);
-}
-
-var g = {};
-
-Object.defineProperty(g, "__esModule", {
-    value: true
-});
-
-g.read = void 0;
-
-function b(t, e) {
-    const r = e.fs.lstatSync(t);
-    if (!r.isSymbolicLink() || !e.followSymbolicLink) {
-        return r;
+            s.push(e);
+        }
+        return this;
+    }
+    removeListener(t, e) {
+        this.off(t, e);
     }
-    try {
-        const r = e.fs.statSync(t);
-        if (e.markSymbolicLink) {
-            r.isSymbolicLink = () => true;
+    off(t, e) {
+        const s = this._eventListeners.get(t) ?? [];
+        const i = s.indexOf(e);
+        if (i !== -1) {
+            s.splice(i, 1);
         }
-        return r;
-    } catch (t) {
-        if (!e.throwErrorOnBrokenSymbolicLink) {
-            return r;
+        if (s.length === 0) {
+            this._eventListeners.delete(t);
         }
-        throw t;
     }
-}
-
-g.read = b;
-
-var E = {};
-
-var v = {};
-
-(function(t) {
-    Object.defineProperty(t, "__esModule", {
-        value: true
-    });
-    t.createFileSystemAdapter = t.FILE_SYSTEM_ADAPTER = void 0;
-    const e = u.default;
-    t.FILE_SYSTEM_ADAPTER = {
-        lstat: e.lstat,
-        stat: e.stat,
-        lstatSync: e.lstatSync,
-        statSync: e.statSync
-    };
-    function r(e) {
-        if (e === undefined) {
-            return t.FILE_SYSTEM_ADAPTER;
-        }
-        return Object.assign(Object.assign({}, t.FILE_SYSTEM_ADAPTER), e);
-    }
-    t.createFileSystemAdapter = r;
-})(v);
-
-Object.defineProperty(E, "__esModule", {
-    value: true
-});
-
-const P = v;
-
-let k = class Settings {
-    constructor(t = {}) {
-        this._options = t;
-        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = P.createFileSystemAdapter(this._options.fs);
-        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
-        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
-    }
-    _getValue(t, e) {
-        return t !== null && t !== void 0 ? t : e;
+    once(t, e) {
+        const s = (...i) => {
+            e(...i);
+            this.off(t, s);
+        };
+        this.on(t, s);
     }
-};
-
-E.default = k;
-
-Object.defineProperty(exports.out, "__esModule", {
-    value: true
-});
-
-exports.out.statSync = exports.out.stat = exports.out.Settings = void 0;
-
-const F = S;
-
-const w = g;
-
-const L = E;
-
-exports.out.Settings = L.default;
-
-function O(t, e, r) {
-    if (typeof e === "function") {
-        F.read(t, D(), e);
-        return;
+    emit(t, ...e) {
+        const s = this._eventListeners.get(t);
+        if (s && s.length > 0) {
+            for (const t of s) {
+                t(...e);
+            }
+        }
     }
-    F.read(t, D(e), r);
-}
-
-exports.out.stat = O;
-
-function T(t, e) {
-    const r = D(e);
-    return w.read(t, r);
-}
-
-exports.out.statSync = T;
-
-function D(t = {}) {
-    if (t instanceof L.default) {
-        return t;
+    listeners(t) {
+        return this._eventListeners.get(t) ?? [];
     }
-    return new L.default(t);
-}
-
-var j = {};
-
-Object.defineProperty(j, "__esModule", {
-    value: true
-});
-
-j.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
-
-const A = process.versions.node.split(".");
-
-if (A[0] === undefined || A[1] === undefined) {
-    throw new Error(`Unexpected behavior. The 'process.versions.node' variable has invalid value: ${process.versions.node}`);
-}
-
-const I = Number.parseInt(A[0], 10);
-
-const M = Number.parseInt(A[1], 10);
-
-const R = 10;
-
-const x = 10;
-
-const V = I > R;
-
-const q = I === R && M >= x;
-
-j.IS_SUPPORT_READDIR_WITH_FILE_TYPES = V || q;
-
-var B = {};
-
-var Y = {};
-
-Object.defineProperty(Y, "__esModule", {
-    value: true
-});
-
-Y.createDirentFromStats = void 0;
-
-class DirentFromStats {
-    constructor(t, e) {
-        this.name = t;
-        this.isBlockDevice = e.isBlockDevice.bind(e);
-        this.isCharacterDevice = e.isCharacterDevice.bind(e);
-        this.isDirectory = e.isDirectory.bind(e);
-        this.isFIFO = e.isFIFO.bind(e);
-        this.isFile = e.isFile.bind(e);
-        this.isSocket = e.isSocket.bind(e);
-        this.isSymbolicLink = e.isSymbolicLink.bind(e);
-    }
-}
-
-function $(t, e) {
-    return new DirentFromStats(t, e);
-}
-
-Y.createDirentFromStats = $;
-
-Object.defineProperty(B, "__esModule", {
-    value: true
-});
-
-B.fs = void 0;
-
-const W = Y;
-
-B.fs = W;
-
-var Q = {};
-
-Object.defineProperty(Q, "__esModule", {
-    value: true
-});
-
-Q.joinPathSegments = void 0;
-
-function N(t, e, r) {
-    if (t.endsWith(r)) {
-        return t + e;
+    removeAllListeners(t) {
+        if (t) {
+            this._eventListeners.delete(t);
+        } else {
+            this._eventListeners.clear();
+        }
     }
-    return t + r + e;
-}
-
-Q.joinPathSegments = N;
-
-Object.defineProperty(f, "__esModule", {
-    value: true
-});
-
-f.readdir = f.readdirWithFileTypes = f.read = void 0;
-
-const U = exports.out;
-
-const H = r.runParallel_1;
-
-const C = j;
-
-const z = B;
-
-const G = Q;
-
-function J(t, e, r) {
-    if (!e.stats && C.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
-        K(t, e, r);
-        return;
+    setMaxListeners(t) {
+        this._maxListeners = t;
     }
-    Z(t, e, r);
-}
+};
 
-f.read = J;
+var s = e;
 
-function K(t, e, r) {
-    e.fs.readdir(t, {
-        withFileTypes: true
-    }, (s, i) => {
-        if (s !== null) {
-            tt(r, s);
-            return;
-        }
-        const n = i.map(r => ({
-            dirent: r,
-            name: r.name,
-            path: G.joinPathSegments(t, r.name, e.pathSegmentSeparator)
-        }));
-        if (!e.followSymbolicLinks) {
-            et(r, n);
-            return;
+var i = class extends s {
+    _hookHandlers;
+    constructor() {
+        super();
+        this._hookHandlers = new Map;
+    }
+    addHandler(t, e) {
+        const s = this._hookHandlers.get(t);
+        if (s) {
+            s.push(e);
+        } else {
+            this._hookHandlers.set(t, [ e ]);
         }
-        const o = n.map(t => X(t, e));
-        H(o, (t, e) => {
-            if (t !== null) {
-                tt(r, t);
-                return;
+    }
+    removeHandler(t, e) {
+        const s = this._hookHandlers.get(t);
+        if (s) {
+            const t = s.indexOf(e);
+            if (t !== -1) {
+                s.splice(t, 1);
             }
-            et(r, e);
-        });
-    });
-}
-
-f.readdirWithFileTypes = K;
-
-function X(t, e) {
-    return r => {
-        if (!t.dirent.isSymbolicLink()) {
-            r(null, t);
-            return;
         }
-        e.fs.stat(t.path, (s, i) => {
-            if (s !== null) {
-                if (e.throwErrorOnBrokenSymbolicLink) {
-                    r(s);
-                    return;
+    }
+    trigger(t, e) {
+        const s = this._hookHandlers.get(t);
+        if (s) {
+            for (const i of s) {
+                try {
+                    i(e);
+                } catch (e) {
+                    this.emit("error", new Error(`Error in hook handler for event "${t}": ${e.message}`));
                 }
-                r(null, t);
-                return;
             }
-            t.dirent = z.fs.createDirentFromStats(t.name, i);
-            r(null, t);
-        });
-    };
-}
+        }
+    }
+    get handlers() {
+        return new Map(this._hookHandlers);
+    }
+};
 
-function Z(t, e, r) {
-    e.fs.readdir(t, (s, i) => {
-        if (s !== null) {
-            tt(r, s);
-            return;
+var r = i;
+
+var o = class extends s {
+    enabled=true;
+    hits=0;
+    misses=0;
+    sets=0;
+    deletes=0;
+    errors=0;
+    constructor(t) {
+        super();
+        if (t !== void 0) {
+            this.enabled = t;
         }
-        const n = i.map(r => {
-            const s = G.joinPathSegments(t, r, e.pathSegmentSeparator);
-            return t => {
-                U.stat(s, e.fsStatSettings, (i, n) => {
-                    if (i !== null) {
-                        t(i);
-                        return;
-                    }
-                    const o = {
-                        name: r,
-                        path: s,
-                        dirent: z.fs.createDirentFromStats(r, n)
-                    };
-                    if (e.stats) {
-                        o.stats = n;
-                    }
-                    t(null, o);
-                });
-            };
-        });
-        H(n, (t, e) => {
-            if (t !== null) {
-                tt(r, t);
-                return;
+        this.reset();
+    }
+    hit() {
+        if (this.enabled) {
+            this.hits++;
+        }
+    }
+    miss() {
+        if (this.enabled) {
+            this.misses++;
+        }
+    }
+    set() {
+        if (this.enabled) {
+            this.sets++;
+        }
+    }
+    delete() {
+        if (this.enabled) {
+            this.deletes++;
+        }
+    }
+    hitsOrMisses(t) {
+        for (const e of t) {
+            if (e === void 0) {
+                this.miss();
+            } else {
+                this.hit();
             }
-            et(r, e);
-        });
-    });
-}
-
-f.readdir = Z;
-
-function tt(t, e) {
-    t(e);
-}
-
-function et(t, e) {
-    t(null, e);
-}
-
-var rt = {};
-
-Object.defineProperty(rt, "__esModule", {
-    value: true
-});
-
-rt.readdir = rt.readdirWithFileTypes = rt.read = void 0;
-
-const st = exports.out;
-
-const it = j;
-
-const nt = B;
-
-const ot = Q;
-
-function at(t, e) {
-    if (!e.stats && it.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
-        return ut(t, e);
+        }
     }
-    return ct(t, e);
-}
-
-rt.read = at;
+    reset() {
+        this.hits = 0;
+        this.misses = 0;
+        this.sets = 0;
+        this.deletes = 0;
+        this.errors = 0;
+    }
+};
 
-function ut(t, e) {
-    const r = e.fs.readdirSync(t, {
-        withFileTypes: true
-    });
-    return r.map(r => {
-        const s = {
-            dirent: r,
-            name: r.name,
-            path: ot.joinPathSegments(t, r.name, e.pathSegmentSeparator)
+var a = o;
+
+var n = [ "sqlite", "postgres", "mysql", "mongo", "redis", "valkey", "etcd" ];
+
+exports.Keyv = class Keyv extends s {
+    opts;
+    iterator;
+    hooks=new r;
+    stats=new a(false);
+    _ttl;
+    _namespace;
+    _store=new Map;
+    _serialize=t.defaultSerialize;
+    _deserialize=t.defaultDeserialize;
+    _compression;
+    _useKeyPrefix=true;
+    _throwOnErrors=false;
+    constructor(e, s) {
+        super();
+        s ??= {};
+        e ??= {};
+        this.opts = {
+            namespace: "keyv",
+            serialize: t.defaultSerialize,
+            deserialize: t.defaultDeserialize,
+            emitErrors: true,
+            store: new Map,
+            ...s
         };
-        if (s.dirent.isSymbolicLink() && e.followSymbolicLinks) {
-            try {
-                const t = e.fs.statSync(s.path);
-                s.dirent = nt.fs.createDirentFromStats(s.name, t);
-            } catch (t) {
-                if (e.throwErrorOnBrokenSymbolicLink) {
-                    throw t;
-                }
+        if (e && e.get) {
+            this.opts.store = e;
+        } else {
+            this.opts = {
+                ...this.opts,
+                ...e
+            };
+        }
+        this._store = this.opts.store ?? new Map;
+        this._compression = this.opts.compression;
+        this._serialize = this.opts.serialize;
+        this._deserialize = this.opts.deserialize;
+        if (this.opts.namespace) {
+            this._namespace = this.opts.namespace;
+        }
+        if (this._store) {
+            if (!this._isValidStorageAdapter(this._store)) {
+                throw new Error("Invalid storage adapter");
+            }
+            if (typeof this._store.on === "function") {
+                this._store.on("error", t => this.emit("error", t));
+            }
+            this._store.namespace = this._namespace;
+            if (typeof this._store[Symbol.iterator] === "function" && this._store instanceof Map) {
+                this.iterator = this.generateIterator(this._store);
+            } else if ("iterator" in this._store && this._store.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(this._store.iterator.bind(this._store));
             }
         }
-        return s;
-    });
-}
-
-rt.readdirWithFileTypes = ut;
-
-function ct(t, e) {
-    const r = e.fs.readdirSync(t);
-    return r.map(r => {
-        const s = ot.joinPathSegments(t, r, e.pathSegmentSeparator);
-        const i = st.statSync(s, e.fsStatSettings);
-        const n = {
-            name: r,
-            path: s,
-            dirent: nt.fs.createDirentFromStats(r, i)
-        };
-        if (e.stats) {
-            n.stats = i;
+        if (this.opts.stats) {
+            this.stats.enabled = this.opts.stats;
+        }
+        if (this.opts.ttl) {
+            this._ttl = this.opts.ttl;
+        }
+        if (this.opts.useKeyPrefix !== void 0) {
+            this._useKeyPrefix = this.opts.useKeyPrefix;
+        }
+        if (this.opts.throwOnErrors !== void 0) {
+            this._throwOnErrors = this.opts.throwOnErrors;
         }
-        return n;
-    });
-}
-
-rt.readdir = ct;
-
-var lt = {};
-
-var dt = {};
-
-(function(t) {
-    Object.defineProperty(t, "__esModule", {
-        value: true
-    });
-    t.createFileSystemAdapter = t.FILE_SYSTEM_ADAPTER = void 0;
-    const e = u.default;
-    t.FILE_SYSTEM_ADAPTER = {
-        lstat: e.lstat,
-        stat: e.stat,
-        lstatSync: e.lstatSync,
-        statSync: e.statSync,
-        readdir: e.readdir,
-        readdirSync: e.readdirSync
-    };
-    function r(e) {
-        if (e === undefined) {
-            return t.FILE_SYSTEM_ADAPTER;
-        }
-        return Object.assign(Object.assign({}, t.FILE_SYSTEM_ADAPTER), e);
-    }
-    t.createFileSystemAdapter = r;
-})(dt);
-
-Object.defineProperty(lt, "__esModule", {
-    value: true
-});
-
-const ht = c.default;
-
-const _t = exports.out;
-
-const ft = dt;
-
-let St = class Settings {
-    constructor(t = {}) {
-        this._options = t;
-        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = ft.createFileSystemAdapter(this._options.fs);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, ht.sep);
-        this.stats = this._getValue(this._options.stats, false);
-        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
-        this.fsStatSettings = new _t.Settings({
-            followSymbolicLink: this.followSymbolicLinks,
-            fs: this.fs,
-            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
-        });
     }
-    _getValue(t, e) {
-        return t !== null && t !== void 0 ? t : e;
+    get store() {
+        return this._store;
     }
-};
-
-lt.default = St;
-
-Object.defineProperty(_, "__esModule", {
-    value: true
-});
-
-_.Settings = _.scandirSync = _.scandir = void 0;
-
-const pt = f;
-
-const yt = rt;
-
-const mt = lt;
-
-_.Settings = mt.default;
-
-function gt(t, e, r) {
-    if (typeof e === "function") {
-        pt.read(t, Et(), e);
-        return;
+    set store(t) {
+        if (this._isValidStorageAdapter(t)) {
+            this._store = t;
+            this.opts.store = t;
+            if (typeof t.on === "function") {
+                t.on("error", t => this.emit("error", t));
+            }
+            if (this._namespace) {
+                this._store.namespace = this._namespace;
+            }
+            if (typeof t[Symbol.iterator] === "function" && t instanceof Map) {
+                this.iterator = this.generateIterator(t);
+            } else if ("iterator" in t && t.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(t.iterator?.bind(t));
+            }
+        } else {
+            throw new Error("Invalid storage adapter");
+        }
     }
-    pt.read(t, Et(e), r);
-}
-
-_.scandir = gt;
-
-function bt(t, e) {
-    const r = Et(e);
-    return yt.read(t, r);
-}
-
-_.scandirSync = bt;
-
-function Et(t = {}) {
-    if (t instanceof mt.default) {
-        return t;
+    get compression() {
+        return this._compression;
     }
-    return new mt.default(t);
-}
-
-var vt = {};
-
-Object.defineProperty(vt, "__esModule", {
-    value: true
-});
-
-vt.joinPathSegments = vt.replacePathSegmentSeparator = vt.isAppliedFilter = vt.isFatalError = void 0;
-
-function Pt(t, e) {
-    if (t.errorFilter === null) {
-        return true;
+    set compression(t) {
+        this._compression = t;
     }
-    return !t.errorFilter(e);
-}
-
-vt.isFatalError = Pt;
-
-function kt(t, e) {
-    return t === null || t(e);
-}
-
-vt.isAppliedFilter = kt;
-
-function Ft(t, e) {
-    return t.split(/[/\\]/).join(e);
-}
-
-vt.replacePathSegmentSeparator = Ft;
-
-function wt(t, e, r) {
-    if (t === "") {
-        return e;
+    get namespace() {
+        return this._namespace;
     }
-    if (t.endsWith(r)) {
-        return t + e;
+    set namespace(t) {
+        this._namespace = t;
+        this.opts.namespace = t;
+        this._store.namespace = t;
+        if (this.opts.store) {
+            this.opts.store.namespace = t;
+        }
     }
-    return t + r + e;
-}
-
-vt.joinPathSegments = wt;
-
-var Lt = {};
-
-Object.defineProperty(Lt, "__esModule", {
-    value: true
-});
-
-const Ot = vt;
-
-class Reader {
-    constructor(t, e) {
-        this._root = t;
-        this._settings = e;
-        this._root = Ot.replacePathSegmentSeparator(t, e.pathSegmentSeparator);
+    get ttl() {
+        return this._ttl;
     }
-}
-
-Lt.default = Reader;
-
-Object.defineProperty(h, "__esModule", {
-    value: true
-});
-
-const Tt = a.default;
-
-const Dt = _;
-
-const jt = i.queueExports;
-
-const At = vt;
-
-const It = Lt;
-
-class AsyncReader extends It.default {
-    constructor(t, e) {
-        super(t, e);
-        this._settings = e;
-        this._scandir = Dt.scandir;
-        this._emitter = new Tt.EventEmitter;
-        this._queue = jt(this._worker.bind(this), this._settings.concurrency);
-        this._isFatalError = false;
-        this._isDestroyed = false;
-        this._queue.drain = () => {
-            if (!this._isFatalError) {
-                this._emitter.emit("end");
-            }
-        };
+    set ttl(t) {
+        this.opts.ttl = t;
+        this._ttl = t;
     }
-    read() {
-        this._isFatalError = false;
-        this._isDestroyed = false;
-        setImmediate(() => {
-            this._pushToQueue(this._root, this._settings.basePath);
-        });
-        return this._emitter;
+    get serialize() {
+        return this._serialize;
     }
-    get isDestroyed() {
-        return this._isDestroyed;
+    set serialize(t) {
+        this.opts.serialize = t;
+        this._serialize = t;
     }
-    destroy() {
-        if (this._isDestroyed) {
-            throw new Error("The reader is already destroyed");
-        }
-        this._isDestroyed = true;
-        this._queue.killAndDrain();
+    get deserialize() {
+        return this._deserialize;
     }
-    onEntry(t) {
-        this._emitter.on("entry", t);
+    set deserialize(t) {
+        this.opts.deserialize = t;
+        this._deserialize = t;
     }
-    onError(t) {
-        this._emitter.once("error", t);
+    get useKeyPrefix() {
+        return this._useKeyPrefix;
     }
-    onEnd(t) {
-        this._emitter.once("end", t);
+    set useKeyPrefix(t) {
+        this._useKeyPrefix = t;
+        this.opts.useKeyPrefix = t;
     }
-    _pushToQueue(t, e) {
-        const r = {
-            directory: t,
-            base: e
-        };
-        this._queue.push(r, t => {
-            if (t !== null) {
-                this._handleError(t);
-            }
-        });
+    get throwOnErrors() {
+        return this._throwOnErrors;
     }
-    _worker(t, e) {
-        this._scandir(t.directory, this._settings.fsScandirSettings, (r, s) => {
-            if (r !== null) {
-                e(r, undefined);
-                return;
-            }
-            for (const e of s) {
-                this._handleEntry(e, t.base);
+    set throwOnErrors(t) {
+        this._throwOnErrors = t;
+        this.opts.throwOnErrors = t;
+    }
+    generateIterator(t) {
+        const e = async function*() {
+            for await (const [e, s] of typeof t === "function" ? t(this._store.namespace) : t) {
+                const t = await this.deserializeData(s);
+                if (this._useKeyPrefix && this._store.namespace && !e.includes(this._store.namespace)) {
+                    continue;
+                }
+                if (typeof t.expires === "number" && Date.now() > t.expires) {
+                    this.delete(e);
+                    continue;
+                }
+                yield [ this._getKeyUnprefix(e), t.value ];
             }
-            e(null, undefined);
-        });
+        };
+        return e.bind(this);
     }
-    _handleError(t) {
-        if (this._isDestroyed || !At.isFatalError(this._settings, t)) {
-            return;
-        }
-        this._isFatalError = true;
-        this._isDestroyed = true;
-        this._emitter.emit("error", t);
+    _checkIterableAdapter() {
+        return n.includes(this._store.opts.dialect) || n.some(t => this._store.opts.url.includes(t));
     }
-    _handleEntry(t, e) {
-        if (this._isDestroyed || this._isFatalError) {
-            return;
+    _getKeyPrefix(t) {
+        if (!this._useKeyPrefix) {
+            return t;
         }
-        const r = t.path;
-        if (e !== undefined) {
-            t.path = At.joinPathSegments(e, t.name, this._settings.pathSegmentSeparator);
+        if (!this._namespace) {
+            return t;
         }
-        if (At.isAppliedFilter(this._settings.entryFilter, t)) {
-            this._emitEntry(t);
+        return `${this._namespace}:${t}`;
+    }
+    _getKeyPrefixArray(t) {
+        if (!this._useKeyPrefix) {
+            return t;
         }
-        if (t.dirent.isDirectory() && At.isAppliedFilter(this._settings.deepFilter, t)) {
-            this._pushToQueue(r, e === undefined ? undefined : t.path);
+        if (!this._namespace) {
+            return t;
         }
+        return t.map(t => `${this._namespace}:${t}`);
     }
-    _emitEntry(t) {
-        this._emitter.emit("entry", t);
-    }
-}
-
-h.default = AsyncReader;
-
-Object.defineProperty(d, "__esModule", {
-    value: true
-});
-
-const Mt = h;
-
-class AsyncProvider {
-    constructor(t, e) {
-        this._root = t;
-        this._settings = e;
-        this._reader = new Mt.default(this._root, this._settings);
-        this._storage = [];
-    }
-    read(t) {
-        this._reader.onError(e => {
-            Rt(t, e);
+    _getKeyUnprefix(t) {
+        if (!this._useKeyPrefix) {
+            return t;
+        }
+        return t.split(":").splice(1).join(":");
+    }
+    _isValidStorageAdapter(t) {
+        return t instanceof Map || typeof t.get === "function" && typeof t.set === "function" && typeof t.delete === "function" && typeof t.clear === "function";
+    }
+    async get(t, e) {
+        const {store: s} = this.opts;
+        const i = Array.isArray(t);
+        const r = i ? this._getKeyPrefixArray(t) : this._getKeyPrefix(t);
+        const o = t => typeof t.expires === "number" && Date.now() > t.expires;
+        if (i) {
+            if (e?.raw === true) {
+                return this.getMany(t, {
+                    raw: true
+                });
+            }
+            return this.getMany(t, {
+                raw: false
+            });
+        }
+        this.hooks.trigger("preGet", {
+            key: r
         });
-        this._reader.onEntry(t => {
-            this._storage.push(t);
+        let a;
+        try {
+            a = await s.get(r);
+        } catch (t) {
+            if (this.throwOnErrors) {
+                throw t;
+            }
+        }
+        const n = typeof a === "string" || this.opts.compression ? await this.deserializeData(a) : a;
+        if (n === void 0 || n === null) {
+            this.hooks.trigger("postGet", {
+                key: r,
+                value: void 0
+            });
+            this.stats.miss();
+            return void 0;
+        }
+        if (o(n)) {
+            await this.delete(t);
+            this.hooks.trigger("postGet", {
+                key: r,
+                value: void 0
+            });
+            this.stats.miss();
+            return void 0;
+        }
+        this.hooks.trigger("postGet", {
+            key: r,
+            value: n
         });
-        this._reader.onEnd(() => {
-            xt(t, this._storage);
+        this.stats.hit();
+        return e?.raw ? n : n.value;
+    }
+    async getMany(t, e) {
+        const {store: s} = this.opts;
+        const i = this._getKeyPrefixArray(t);
+        const r = t => typeof t.expires === "number" && Date.now() > t.expires;
+        this.hooks.trigger("preGetMany", {
+            keys: i
         });
-        this._reader.read();
-    }
-}
-
-d.default = AsyncProvider;
-
-function Rt(t, e) {
-    t(e);
-}
-
-function xt(t, e) {
-    t(null, e);
-}
-
-var Vt = {};
-
-Object.defineProperty(Vt, "__esModule", {
-    value: true
-});
-
-const qt = l.default;
-
-const Bt = h;
-
-class StreamProvider {
-    constructor(t, e) {
-        this._root = t;
-        this._settings = e;
-        this._reader = new Bt.default(this._root, this._settings);
-        this._stream = new qt.Readable({
-            objectMode: true,
-            read: () => {},
-            destroy: () => {
-                if (!this._reader.isDestroyed) {
-                    this._reader.destroy();
+        if (s.getMany === void 0) {
+            const t = i.map(async t => {
+                const i = await s.get(t);
+                const o = typeof i === "string" || this.opts.compression ? await this.deserializeData(i) : i;
+                if (o === void 0 || o === null) {
+                    return void 0;
+                }
+                if (r(o)) {
+                    await this.delete(t);
+                    return void 0;
                 }
+                return e?.raw ? o : o.value;
+            });
+            const o = await Promise.allSettled(t);
+            const a = o.map(t => t.value);
+            this.hooks.trigger("postGetMany", a);
+            if (a.length > 0) {
+                this.stats.hit();
             }
-        });
+            return a;
+        }
+        const o = await s.getMany(i);
+        const a = [];
+        const n = [];
+        for (const s in o) {
+            let i = o[s];
+            if (typeof i === "string") {
+                i = await this.deserializeData(i);
+            }
+            if (i === void 0 || i === null) {
+                a.push(void 0);
+                continue;
+            }
+            if (r(i)) {
+                n.push(t[s]);
+                a.push(void 0);
+                continue;
+            }
+            const h = e?.raw ? i : i.value;
+            a.push(h);
+        }
+        if (n.length > 0) {
+            await this.deleteMany(n);
+        }
+        this.hooks.trigger("postGetMany", a);
+        if (a.length > 0) {
+            this.stats.hit();
+        }
+        return a;
     }
-    read() {
-        this._reader.onError(t => {
-            this._stream.emit("error", t);
+    async getRaw(t) {
+        const {store: e} = this.opts;
+        const s = this._getKeyPrefix(t);
+        this.hooks.trigger("preGetRaw", {
+            key: s
         });
-        this._reader.onEntry(t => {
-            this._stream.push(t);
+        const i = await e.get(s);
+        if (i === void 0 || i === null) {
+            this.hooks.trigger("postGetRaw", {
+                key: s,
+                value: void 0
+            });
+            this.stats.miss();
+            return void 0;
+        }
+        const r = typeof i === "string" || this.opts.compression ? await this.deserializeData(i) : i;
+        if (r !== void 0 && r.expires !== void 0 && r.expires !== null && r.expires < Date.now()) {
+            this.hooks.trigger("postGetRaw", {
+                key: s,
+                value: void 0
+            });
+            this.stats.miss();
+            await this.delete(t);
+            return void 0;
+        }
+        this.stats.hit();
+        this.hooks.trigger("postGetRaw", {
+            key: s,
+            value: r
         });
-        this._reader.onEnd(() => {
-            this._stream.push(null);
+        return r;
+    }
+    async getManyRaw(t) {
+        const {store: e} = this.opts;
+        const s = this._getKeyPrefixArray(t);
+        if (t.length === 0) {
+            const e = Array.from({
+                length: t.length
+            }).fill(void 0);
+            this.stats.misses += t.length;
+            this.hooks.trigger("postGetManyRaw", {
+                keys: s,
+                values: e
+            });
+            return e;
+        }
+        let i = [];
+        if (e.getMany === void 0) {
+            const t = s.map(async t => {
+                const s = await e.get(t);
+                if (s !== void 0 && s !== null) {
+                    return this.deserializeData(s);
+                }
+                return void 0;
+            });
+            const r = await Promise.allSettled(t);
+            i = r.map(t => t.value);
+        } else {
+            const t = await e.getMany(s);
+            for (const e of t) {
+                if (e !== void 0 && e !== null) {
+                    i.push(await this.deserializeData(e));
+                } else {
+                    i.push(void 0);
+                }
+            }
+        }
+        const r = [];
+        const o = t => typeof t.expires === "number" && Date.now() > t.expires;
+        for (const [t, e] of i.entries()) {
+            if (e !== void 0 && o(e)) {
+                r.push(s[t]);
+                i[t] = void 0;
+            }
+        }
+        if (r.length > 0) {
+            await this.deleteMany(r);
+        }
+        this.stats.hitsOrMisses(i);
+        this.hooks.trigger("postGetManyRaw", {
+            keys: s,
+            values: i
         });
-        this._reader.read();
-        return this._stream;
+        return i;
     }
-}
-
-Vt.default = StreamProvider;
-
-var Yt = {};
-
-var $t = {};
-
-Object.defineProperty($t, "__esModule", {
-    value: true
-});
-
-const Wt = _;
-
-const Qt = vt;
-
-const Nt = Lt;
-
-class SyncReader extends Nt.default {
-    constructor() {
-        super(...arguments);
-        this._scandir = Wt.scandirSync;
-        this._storage = [];
-        this._queue = new Set;
-    }
-    read() {
-        this._pushToQueue(this._root, this._settings.basePath);
-        this._handleQueue();
-        return this._storage;
-    }
-    _pushToQueue(t, e) {
-        this._queue.add({
-            directory: t,
-            base: e
+    async set(t, e, s) {
+        const i = {
+            key: t,
+            value: e,
+            ttl: s
+        };
+        this.hooks.trigger("preSet", i);
+        const r = this._getKeyPrefix(i.key);
+        i.ttl ??= this._ttl;
+        if (i.ttl === 0) {
+            i.ttl = void 0;
+        }
+        const {store: o} = this.opts;
+        const a = typeof i.ttl === "number" ? Date.now() + i.ttl : void 0;
+        if (typeof i.value === "symbol") {
+            this.emit("error", "symbol cannot be serialized");
+            throw new Error("symbol cannot be serialized");
+        }
+        const n = {
+            value: i.value,
+            expires: a
+        };
+        const h = await this.serializeData(n);
+        let l = true;
+        try {
+            const t = await o.set(r, h, i.ttl);
+            if (typeof t === "boolean") {
+                l = t;
+            }
+        } catch (t) {
+            l = false;
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
+        }
+        this.hooks.trigger("postSet", {
+            key: r,
+            value: h,
+            ttl: s
         });
+        this.stats.set();
+        return l;
     }
-    _handleQueue() {
-        for (const t of this._queue.values()) {
-            this._handleDirectory(t.directory, t.base);
+    async setMany(t) {
+        let e = [];
+        try {
+            if (this._store.setMany === void 0) {
+                const s = [];
+                for (const e of t) {
+                    s.push(this.set(e.key, e.value, e.ttl));
+                }
+                const i = await Promise.all(s);
+                e = i;
+            } else {
+                const s = await Promise.all(t.map(async ({key: t, value: e, ttl: s}) => {
+                    s ??= this._ttl;
+                    if (s === 0) {
+                        s = void 0;
+                    }
+                    const i = typeof s === "number" ? Date.now() + s : void 0;
+                    if (typeof e === "symbol") {
+                        this.emit("error", "symbol cannot be serialized");
+                        throw new Error("symbol cannot be serialized");
+                    }
+                    const r = {
+                        value: e,
+                        expires: i
+                    };
+                    const o = await this.serializeData(r);
+                    const a = this._getKeyPrefix(t);
+                    return {
+                        key: a,
+                        value: o,
+                        ttl: s
+                    };
+                }));
+                e = await this._store.setMany(s);
+            }
+        } catch (s) {
+            this.emit("error", s);
+            if (this._throwOnErrors) {
+                throw s;
+            }
+            e = t.map(() => false);
         }
+        return e;
     }
-    _handleDirectory(t, e) {
+    async delete(t) {
+        const {store: e} = this.opts;
+        if (Array.isArray(t)) {
+            return this.deleteMany(t);
+        }
+        const s = this._getKeyPrefix(t);
+        this.hooks.trigger("preDelete", {
+            key: s
+        });
+        let i = true;
         try {
-            const r = this._scandir(t, this._settings.fsScandirSettings);
-            for (const t of r) {
-                this._handleEntry(t, e);
+            const t = await e.delete(s);
+            if (typeof t === "boolean") {
+                i = t;
             }
         } catch (t) {
-            this._handleError(t);
+            i = false;
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
         }
+        this.hooks.trigger("postDelete", {
+            key: s,
+            value: i
+        });
+        this.stats.delete();
+        return i;
     }
-    _handleError(t) {
-        if (!Qt.isFatalError(this._settings, t)) {
-            return;
+    async deleteMany(t) {
+        try {
+            const {store: e} = this.opts;
+            const s = this._getKeyPrefixArray(t);
+            this.hooks.trigger("preDelete", {
+                key: s
+            });
+            if (e.deleteMany !== void 0) {
+                return await e.deleteMany(s);
+            }
+            const i = s.map(async t => e.delete(t));
+            const r = await Promise.all(i);
+            const o = r.every(Boolean);
+            this.hooks.trigger("postDelete", {
+                key: s,
+                value: o
+            });
+            return o;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
+            return false;
         }
-        throw t;
     }
-    _handleEntry(t, e) {
-        const r = t.path;
-        if (e !== undefined) {
-            t.path = Qt.joinPathSegments(e, t.name, this._settings.pathSegmentSeparator);
+    async clear() {
+        this.emit("clear");
+        const {store: t} = this.opts;
+        try {
+            await t.clear();
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
         }
-        if (Qt.isAppliedFilter(this._settings.entryFilter, t)) {
-            this._pushToStorage(t);
+    }
+    async has(t) {
+        if (Array.isArray(t)) {
+            return this.hasMany(t);
         }
-        if (t.dirent.isDirectory() && Qt.isAppliedFilter(this._settings.deepFilter, t)) {
-            this._pushToQueue(r, e === undefined ? undefined : t.path);
+        const e = this._getKeyPrefix(t);
+        const {store: s} = this.opts;
+        if (s.has !== void 0 && !(s instanceof Map)) {
+            return s.has(e);
         }
+        let i;
+        try {
+            i = await s.get(e);
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
+            return false;
+        }
+        if (i) {
+            const t = await this.deserializeData(i);
+            if (t) {
+                if (t.expires === void 0 || t.expires === null) {
+                    return true;
+                }
+                return t.expires > Date.now();
+            }
+        }
+        return false;
     }
-    _pushToStorage(t) {
-        this._storage.push(t);
-    }
-}
-
-$t.default = SyncReader;
-
-Object.defineProperty(Yt, "__esModule", {
-    value: true
-});
-
-const Ut = $t;
-
-class SyncProvider {
-    constructor(t, e) {
-        this._root = t;
-        this._settings = e;
-        this._reader = new Ut.default(this._root, this._settings);
+    async hasMany(t) {
+        const e = this._getKeyPrefixArray(t);
+        const {store: s} = this.opts;
+        if (s.hasMany !== void 0) {
+            return s.hasMany(e);
+        }
+        const i = [];
+        for (const e of t) {
+            i.push(await this.has(e));
+        }
+        return i;
     }
-    read() {
-        return this._reader.read();
+    async disconnect() {
+        const {store: t} = this.opts;
+        this.emit("disconnect");
+        if (typeof t.disconnect === "function") {
+            return t.disconnect();
+        }
     }
-}
-
-Yt.default = SyncProvider;
-
-var Ht = {};
-
-Object.defineProperty(Ht, "__esModule", {
-    value: true
-});
-
-const Ct = c.default;
-
-const zt = _;
-
-class Settings {
-    constructor(t = {}) {
-        this._options = t;
-        this.basePath = this._getValue(this._options.basePath, undefined);
-        this.concurrency = this._getValue(this._options.concurrency, Number.POSITIVE_INFINITY);
-        this.deepFilter = this._getValue(this._options.deepFilter, null);
-        this.entryFilter = this._getValue(this._options.entryFilter, null);
-        this.errorFilter = this._getValue(this._options.errorFilter, null);
-        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, Ct.sep);
-        this.fsScandirSettings = new zt.Settings({
-            followSymbolicLinks: this._options.followSymbolicLinks,
-            fs: this._options.fs,
-            pathSegmentSeparator: this._options.pathSegmentSeparator,
-            stats: this._options.stats,
-            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
-        });
+    emit(t, ...e) {
+        if (t === "error" && !this.opts.emitErrors) {
+            return;
+        }
+        super.emit(t, ...e);
     }
-    _getValue(t, e) {
-        return t !== null && t !== void 0 ? t : e;
+    async serializeData(t) {
+        if (!this._serialize) {
+            return t;
+        }
+        if (this._compression?.compress) {
+            return this._serialize({
+                value: await this._compression.compress(t.value),
+                expires: t.expires
+            });
+        }
+        return this._serialize(t);
     }
-}
-
-Ht.default = Settings;
-
-Object.defineProperty(exports.out$1, "__esModule", {
-    value: true
-});
-
-exports.out$1.Settings = exports.out$1.walkStream = exports.out$1.walkSync = exports.out$1.walk = void 0;
-
-const Gt = d;
-
-const Jt = Vt;
-
-const Kt = Yt;
-
-const Xt = Ht;
-
-exports.out$1.Settings = Xt.default;
-
-function Zt(t, e, r) {
-    if (typeof e === "function") {
-        new Gt.default(t, re()).read(e);
-        return;
+    async deserializeData(t) {
+        if (!this._deserialize) {
+            return t;
+        }
+        if (this._compression?.decompress && typeof t === "string") {
+            const e = await this._deserialize(t);
+            return {
+                value: await this._compression.decompress(e?.value),
+                expires: e?.expires
+            };
+        }
+        if (typeof t === "string") {
+            return this._deserialize(t);
+        }
+        return void 0;
     }
-    new Gt.default(t, re(e)).read(r);
-}
-
-exports.out$1.walk = Zt;
-
-function te(t, e) {
-    const r = re(e);
-    const s = new Kt.default(t, r);
-    return s.read();
-}
-
-exports.out$1.walkSync = te;
-
-function ee(t, e) {
-    const r = re(e);
-    const s = new Jt.default(t, r);
-    return s.read();
-}
-
-exports.out$1.walkStream = ee;
+};
 
-function re(t = {}) {
-    if (t instanceof Xt.default) {
-        return t;
-    }
-    return new Xt.default(t);
-}
+exports.index_default = exports.Keyv;