lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.13.cjs

@@ -1,795 +1,361 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const t = require("./Package.internal.11.cjs");
-
 var e = class {
     _eventListeners;
     _maxListeners;
-    constructor() {
+    _logger;
+    _throwOnEmitError=false;
+    _throwOnEmptyListeners=false;
+    _errorEvent="error";
+    constructor(e) {
         this._eventListeners = new Map;
         this._maxListeners = 100;
+        this._logger = e?.logger;
+        if (e?.throwOnEmitError !== void 0) {
+            this._throwOnEmitError = e.throwOnEmitError;
+        }
+        if (e?.throwOnEmptyListeners !== void 0) {
+            this._throwOnEmptyListeners = e.throwOnEmptyListeners;
+        }
     }
-    maxListeners() {
-        return this._maxListeners;
+    get logger() {
+        return this._logger;
     }
-    addListener(t, e) {
-        this.on(t, e);
+    set logger(e) {
+        this._logger = e;
     }
-    on(t, e) {
-        if (!this._eventListeners.has(t)) {
-            this._eventListeners.set(t, []);
-        }
-        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.`);
-            }
-            s.push(e);
-        }
-        return this;
+    get throwOnEmitError() {
+        return this._throwOnEmitError;
     }
-    removeListener(t, e) {
-        this.off(t, e);
+    set throwOnEmitError(e) {
+        this._throwOnEmitError = e;
     }
-    off(t, e) {
-        const s = this._eventListeners.get(t) ?? [];
-        const i = s.indexOf(e);
-        if (i !== -1) {
-            s.splice(i, 1);
-        }
-        if (s.length === 0) {
-            this._eventListeners.delete(t);
-        }
+    get throwOnEmptyListeners() {
+        return this._throwOnEmptyListeners;
     }
-    once(t, e) {
-        const s = (...i) => {
-            e(...i);
-            this.off(t, s);
+    set throwOnEmptyListeners(e) {
+        this._throwOnEmptyListeners = e;
+    }
+    once(e, t) {
+        const r = (...o) => {
+            this.off(e, r);
+            t(...o);
         };
-        this.on(t, s);
+        this.on(e, r);
+        return this;
     }
-    emit(t, ...e) {
-        const s = this._eventListeners.get(t);
-        if (s && s.length > 0) {
-            for (const t of s) {
-                t(...e);
-            }
+    listenerCount(e) {
+        if (e === void 0) {
+            return this.getAllListeners().length;
         }
+        const t = this._eventListeners.get(e);
+        return t ? t.length : 0;
     }
-    listeners(t) {
-        return this._eventListeners.get(t) ?? [];
+    eventNames() {
+        return [ ...this._eventListeners.keys() ];
     }
-    removeAllListeners(t) {
-        if (t) {
-            this._eventListeners.delete(t);
-        } else {
-            this._eventListeners.clear();
+    rawListeners(e) {
+        if (e === void 0) {
+            return this.getAllListeners();
         }
+        return this._eventListeners.get(e) ?? [];
     }
-    setMaxListeners(t) {
-        this._maxListeners = t;
-    }
-};
-
-var s = e;
-
-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 ]);
-        }
+    prependListener(e, t) {
+        const r = this._eventListeners.get(e) ?? [];
+        r.unshift(t);
+        this._eventListeners.set(e, r);
+        return this;
     }
-    removeHandler(t, e) {
-        const s = this._hookHandlers.get(t);
-        if (s) {
-            const t = s.indexOf(e);
-            if (t !== -1) {
-                s.splice(t, 1);
-            }
-        }
+    prependOnceListener(e, t) {
+        const r = (...o) => {
+            this.off(e, r);
+            t(...o);
+        };
+        this.prependListener(e, r);
+        return this;
     }
-    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}`));
-                }
-            }
-        }
+    maxListeners() {
+        return this._maxListeners;
     }
-    get handlers() {
-        return new Map(this._hookHandlers);
+    addListener(e, t) {
+        this.on(e, t);
+        return this;
     }
-};
-
-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;
+    on(e, t) {
+        if (!this._eventListeners.has(e)) {
+            this._eventListeners.set(e, []);
         }
-        this.reset();
-    }
-    hit() {
-        if (this.enabled) {
-            this.hits++;
+        const r = this._eventListeners.get(e);
+        if (r) {
+            if (r.length >= this._maxListeners) {
+                console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${r.length + 1} ${e} listeners added. Use setMaxListeners() to increase limit.`);
+            }
+            r.push(t);
         }
+        return this;
     }
-    miss() {
-        if (this.enabled) {
-            this.misses++;
-        }
+    removeListener(e, t) {
+        this.off(e, t);
+        return this;
     }
-    set() {
-        if (this.enabled) {
-            this.sets++;
+    off(e, t) {
+        const r = this._eventListeners.get(e) ?? [];
+        const o = r.indexOf(t);
+        if (o !== -1) {
+            r.splice(o, 1);
         }
-    }
-    delete() {
-        if (this.enabled) {
-            this.deletes++;
+        if (r.length === 0) {
+            this._eventListeners.delete(e);
         }
+        return this;
     }
-    hitsOrMisses(t) {
-        for (const e of t) {
-            if (e === void 0) {
-                this.miss();
+    emit(e, ...t) {
+        let r = false;
+        const o = this._eventListeners.get(e);
+        if (o && o.length > 0) {
+            for (const e of o) {
+                e(...t);
+                r = true;
+            }
+        }
+        if (e === this._errorEvent) {
+            const e = t[0] instanceof Error ? t[0] : new Error(`${t[0]}`);
+            if (this._throwOnEmitError && !r) {
+                throw e;
             } else {
-                this.hit();
+                if (this.listeners(this._errorEvent).length === 0 && this._throwOnEmptyListeners === true) {
+                    throw e;
+                }
             }
         }
+        return r;
     }
-    reset() {
-        this.hits = 0;
-        this.misses = 0;
-        this.sets = 0;
-        this.deletes = 0;
-        this.errors = 0;
+    listeners(e) {
+        return this._eventListeners.get(e) ?? [];
     }
-};
-
-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 (e && e.get) {
-            this.opts.store = e;
+    removeAllListeners(e) {
+        if (e !== void 0) {
+            this._eventListeners.delete(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;
+            this._eventListeners.clear();
         }
-        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 this;
+    }
+    setMaxListeners(e) {
+        this._maxListeners = e;
+        for (const t of this._eventListeners.values()) {
+            if (t.length > e) {
+                t.splice(e);
             }
         }
-        if (this.opts.stats) {
-            this.stats.enabled = this.opts.stats;
-        }
-        if (this.opts.ttl) {
-            this._ttl = this.opts.ttl;
+    }
+    getAllListeners() {
+        let e = [];
+        for (const t of this._eventListeners.values()) {
+            e = [ ...e, ...t ];
         }
-        if (this.opts.useKeyPrefix !== void 0) {
-            this._useKeyPrefix = this.opts.useKeyPrefix;
+        return e;
+    }
+};
+
+exports.Hookified = class Hookified extends e {
+    _hooks;
+    _throwOnHookError=false;
+    _enforceBeforeAfter=false;
+    _deprecatedHooks;
+    _allowDeprecated=true;
+    constructor(e) {
+        super({
+            logger: e?.logger,
+            throwOnEmitError: e?.throwOnEmitError,
+            throwOnEmptyListeners: e?.throwOnEmptyListeners
+        });
+        this._hooks = new Map;
+        this._deprecatedHooks = e?.deprecatedHooks ? new Map(e.deprecatedHooks) : new Map;
+        if (e?.throwOnHookError !== void 0) {
+            this._throwOnHookError = e.throwOnHookError;
+        } else if (e?.throwHookErrors !== void 0) {
+            this._throwOnHookError = e.throwHookErrors;
         }
-        if (this.opts.throwOnErrors !== void 0) {
-            this._throwOnErrors = this.opts.throwOnErrors;
+        if (e?.enforceBeforeAfter !== void 0) {
+            this._enforceBeforeAfter = e.enforceBeforeAfter;
         }
-    }
-    get store() {
-        return this._store;
-    }
-    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");
+        if (e?.allowDeprecated !== void 0) {
+            this._allowDeprecated = e.allowDeprecated;
         }
     }
-    get compression() {
-        return this._compression;
-    }
-    set compression(t) {
-        this._compression = t;
-    }
-    get namespace() {
-        return this._namespace;
-    }
-    set namespace(t) {
-        this._namespace = t;
-        this.opts.namespace = t;
-        this._store.namespace = t;
-        if (this.opts.store) {
-            this.opts.store.namespace = t;
-        }
+    get hooks() {
+        return this._hooks;
     }
-    get ttl() {
-        return this._ttl;
+    get throwHookErrors() {
+        return this._throwOnHookError;
     }
-    set ttl(t) {
-        this.opts.ttl = t;
-        this._ttl = t;
+    set throwHookErrors(e) {
+        this._throwOnHookError = e;
     }
-    get serialize() {
-        return this._serialize;
+    get throwOnHookError() {
+        return this._throwOnHookError;
     }
-    set serialize(t) {
-        this.opts.serialize = t;
-        this._serialize = t;
+    set throwOnHookError(e) {
+        this._throwOnHookError = e;
     }
-    get deserialize() {
-        return this._deserialize;
+    get enforceBeforeAfter() {
+        return this._enforceBeforeAfter;
     }
-    set deserialize(t) {
-        this.opts.deserialize = t;
-        this._deserialize = t;
+    set enforceBeforeAfter(e) {
+        this._enforceBeforeAfter = e;
     }
-    get useKeyPrefix() {
-        return this._useKeyPrefix;
+    get deprecatedHooks() {
+        return this._deprecatedHooks;
     }
-    set useKeyPrefix(t) {
-        this._useKeyPrefix = t;
-        this.opts.useKeyPrefix = t;
+    set deprecatedHooks(e) {
+        this._deprecatedHooks = e;
     }
-    get throwOnErrors() {
-        return this._throwOnErrors;
+    get allowDeprecated() {
+        return this._allowDeprecated;
     }
-    set throwOnErrors(t) {
-        this._throwOnErrors = t;
-        this.opts.throwOnErrors = t;
+    set allowDeprecated(e) {
+        this._allowDeprecated = e;
     }
-    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 ];
+    validateHookName(e) {
+        if (this._enforceBeforeAfter) {
+            const t = e.trim().toLocaleLowerCase();
+            if (!t.startsWith("before") && !t.startsWith("after")) {
+                throw new Error(`Hook event "${e}" must start with "before" or "after" when enforceBeforeAfter is enabled`);
             }
-        };
-        return e.bind(this);
-    }
-    _checkIterableAdapter() {
-        return n.includes(this._store.opts.dialect) || n.some(t => this._store.opts.url.includes(t));
-    }
-    _getKeyPrefix(t) {
-        if (!this._useKeyPrefix) {
-            return t;
-        }
-        if (!this._namespace) {
-            return t;
         }
-        return `${this._namespace}:${t}`;
     }
-    _getKeyPrefixArray(t) {
-        if (!this._useKeyPrefix) {
-            return t;
-        }
-        if (!this._namespace) {
-            return t;
-        }
-        return t.map(t => `${this._namespace}:${t}`);
-    }
-    _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
+    checkDeprecatedHook(e) {
+        if (this._deprecatedHooks.has(e)) {
+            const t = this._deprecatedHooks.get(e);
+            const r = `Hook "${e}" is deprecated${t ? `: ${t}` : ""}`;
+            this.emit("warn", {
+                hook: e,
+                message: r
             });
-        }
-        this.hooks.trigger("preGet", {
-            key: r
-        });
-        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.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
-        });
-        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();
+            if (this.logger?.warn) {
+                this.logger.warn(r);
             }
-            return a;
+            return this._allowDeprecated;
         }
-        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);
+        return true;
+    }
+    onHook(e, t) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return;
         }
-        this.hooks.trigger("postGetMany", a);
-        if (a.length > 0) {
-            this.stats.hit();
+        const r = this._hooks.get(e);
+        if (r) {
+            r.push(t);
+        } else {
+            this._hooks.set(e, [ t ]);
         }
-        return a;
     }
-    async getRaw(t) {
-        const {store: e} = this.opts;
-        const s = this._getKeyPrefix(t);
-        this.hooks.trigger("preGetRaw", {
-            key: s
-        });
-        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;
+    onHookEntry(e) {
+        this.onHook(e.event, e.handler);
+    }
+    addHook(e, t) {
+        this.onHook(e, t);
+    }
+    onHooks(e) {
+        for (const t of e) {
+            this.onHook(t.event, t.handler);
         }
-        this.stats.hit();
-        this.hooks.trigger("postGetRaw", {
-            key: s,
-            value: r
-        });
-        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;
+    prependHook(e, t) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return;
         }
-        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);
+        const r = this._hooks.get(e);
+        if (r) {
+            r.unshift(t);
         } 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);
-                }
-            }
+            this._hooks.set(e, [ t ]);
         }
-        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
-        });
-        return i;
     }
-    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");
+    prependOnceHook(e, t) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return;
         }
-        const n = {
-            value: i.value,
-            expires: a
+        const r = async (...o) => {
+            this.removeHook(e, r);
+            return t(...o);
         };
-        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;
+        this.prependHook(e, r);
     }
-    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);
+    onceHook(e, t) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return;
         }
-        return e;
+        const r = async (...o) => {
+            this.removeHook(e, r);
+            return t(...o);
+        };
+        this.onHook(e, r);
     }
-    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 t = await e.delete(s);
-            if (typeof t === "boolean") {
-                i = t;
-            }
-        } catch (t) {
-            i = false;
-            this.emit("error", t);
-            if (this._throwOnErrors) {
-                throw t;
-            }
+    removeHook(e, t) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return;
         }
-        this.hooks.trigger("postDelete", {
-            key: s,
-            value: i
-        });
-        this.stats.delete();
-        return i;
-    }
-    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 r = this._hooks.get(e);
+        if (r) {
+            const e = r.indexOf(t);
+            if (e !== -1) {
+                r.splice(e, 1);
             }
-            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;
         }
     }
-    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;
-            }
+    removeHooks(e) {
+        for (const t of e) {
+            this.removeHook(t.event, t.handler);
         }
     }
-    async has(t) {
-        if (Array.isArray(t)) {
-            return this.hasMany(t);
-        }
-        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;
+    async hook(e, ...t) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return;
         }
-        if (i) {
-            const t = await this.deserializeData(i);
-            if (t) {
-                if (t.expires === void 0 || t.expires === null) {
-                    return true;
+        const r = this._hooks.get(e);
+        if (r) {
+            for (const o of r) {
+                try {
+                    await o(...t);
+                } catch (t) {
+                    const r = `${e}: ${t.message}`;
+                    this.emit("error", new Error(r));
+                    if (this.logger) {
+                        this.logger.error(r);
+                    }
+                    if (this._throwOnHookError) {
+                        throw new Error(r);
+                    }
                 }
-                return t.expires > Date.now();
             }
         }
-        return false;
     }
-    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;
+    async beforeHook(e, ...t) {
+        await this.hook(`before:${e}`, ...t);
     }
-    async disconnect() {
-        const {store: t} = this.opts;
-        this.emit("disconnect");
-        if (typeof t.disconnect === "function") {
-            return t.disconnect();
-        }
+    async afterHook(e, ...t) {
+        await this.hook(`after:${e}`, ...t);
     }
-    emit(t, ...e) {
-        if (t === "error" && !this.opts.emitErrors) {
-            return;
-        }
-        super.emit(t, ...e);
+    async callHook(e, ...t) {
+        await this.hook(e, ...t);
     }
-    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
-            });
+    getHooks(e) {
+        this.validateHookName(e);
+        if (!this.checkDeprecatedHook(e)) {
+            return void 0;
         }
-        return this._serialize(t);
+        return this._hooks.get(e);
     }
-    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;
+    clearHooks() {
+        this._hooks.clear();
     }
 };
-
-exports.index_default = exports.Keyv;