lakutata 2.0.80 → 2.0.82

package/vendor/Package.67.cjs

@@ -1,57 +1,59 @@
 "use strict";
 
-const e = require("buffer");
+const t = require("buffer");
 
-var t = s => {
-    if (s === void 0 || s === null) {
+var _serialize = (e, s = true) => {
+    if (e === void 0 || e === null) {
         return "null";
     }
-    if (typeof s === "string") {
-        return JSON.stringify(s.startsWith(":") ? ":" + s : s);
+    if (typeof e === "string") {
+        return JSON.stringify(s && e.startsWith(":") ? `:${e}` : e);
     }
-    if (e.Buffer.isBuffer(s)) {
-        return JSON.stringify(":base64:" + s.toString("base64"));
+    if (t.Buffer.isBuffer(e)) {
+        return JSON.stringify(`:base64:${e.toString("base64")}`);
     }
-    if (s?.toJSON) {
-        s = s.toJSON();
+    if (e?.toJSON) {
+        e = e.toJSON();
     }
-    if (typeof s === "object") {
-        let e = "";
-        const i = Array.isArray(s);
-        e = i ? "[" : "{";
+    if (typeof e === "object") {
+        let t = "";
+        const i = Array.isArray(e);
+        t = i ? "[" : "{";
         let r = true;
-        for (const o in s) {
-            const a = typeof s[o] === "function" || !i && s[o] === void 0;
-            if (!Object.hasOwn(s, o) || a) {
+        for (const o in e) {
+            const a = typeof e[o] === "function" || !i && e[o] === void 0;
+            if (!Object.hasOwn(e, o) || a) {
                 continue;
             }
             if (!r) {
-                e += ",";
+                t += ",";
             }
             r = false;
             if (i) {
-                e += t(s[o]);
-            } else if (s[o] !== void 0) {
-                e += t(o) + ":" + t(s[o]);
+                t += _serialize(e[o], s);
+            } else if (e[o] !== void 0) {
+                t += `${_serialize(o, false)}:${_serialize(e[o], s)}`;
             }
         }
-        e += i ? "]" : "}";
-        return e;
+        t += i ? "]" : "}";
+        return t;
     }
-    return JSON.stringify(s);
+    return JSON.stringify(e);
 };
 
-var s = t => JSON.parse(t, ((t, s) => {
+var defaultSerialize = t => _serialize(t, true);
+
+var defaultDeserialize = e => JSON.parse(e, ((e, s) => {
     if (typeof s === "string") {
         if (s.startsWith(":base64:")) {
-            return e.Buffer.from(s.slice(8), "base64");
+            return t.Buffer.from(s.slice(8), "base64");
         }
         return s.startsWith(":") ? s.slice(1) : s;
     }
     return s;
 }));
 
-var i = class {
+var e = class {
     _eventListeners;
     _maxListeners;
     constructor() {
@@ -61,98 +63,98 @@ var i = class {
     maxListeners() {
         return this._maxListeners;
     }
-    addListener(e, t) {
-        this.on(e, t);
+    addListener(t, e) {
+        this.on(t, e);
     }
-    on(e, t) {
-        if (!this._eventListeners.has(e)) {
-            this._eventListeners.set(e, []);
+    on(t, e) {
+        if (!this._eventListeners.has(t)) {
+            this._eventListeners.set(t, []);
         }
-        const s = this._eventListeners.get(e);
+        const s = this._eventListeners.get(t);
         if (s) {
             if (s.length >= this._maxListeners) {
-                console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${e} listeners added. Use setMaxListeners() to increase limit.`);
+                console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${t} listeners added. Use setMaxListeners() to increase limit.`);
             }
-            s.push(t);
+            s.push(e);
         }
         return this;
     }
-    removeListener(e, t) {
-        this.off(e, t);
+    removeListener(t, e) {
+        this.off(t, e);
     }
-    off(e, t) {
-        const s = this._eventListeners.get(e) ?? [];
-        const i = s.indexOf(t);
+    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(e);
+            this._eventListeners.delete(t);
         }
     }
-    once(e, t) {
-        const s = (...i) => {
-            t(...i);
-            this.off(e, s);
+    once(t, e) {
+        const onceListener = (...s) => {
+            e(...s);
+            this.off(t, onceListener);
         };
-        this.on(e, s);
+        this.on(t, onceListener);
     }
-    emit(e, ...t) {
-        const s = this._eventListeners.get(e);
+    emit(t, ...e) {
+        const s = this._eventListeners.get(t);
         if (s && s.length > 0) {
-            for (const e of s) {
-                e(...t);
+            for (const t of s) {
+                t(...e);
             }
         }
     }
-    listeners(e) {
-        return this._eventListeners.get(e) ?? [];
+    listeners(t) {
+        return this._eventListeners.get(t) ?? [];
     }
-    removeAllListeners(e) {
-        if (e) {
-            this._eventListeners.delete(e);
+    removeAllListeners(t) {
+        if (t) {
+            this._eventListeners.delete(t);
         } else {
             this._eventListeners.clear();
         }
     }
-    setMaxListeners(e) {
-        this._maxListeners = e;
+    setMaxListeners(t) {
+        this._maxListeners = t;
     }
 };
 
-var r = i;
+var s = e;
 
-var o = class extends r {
+var i = class extends s {
     _hookHandlers;
     constructor() {
         super();
         this._hookHandlers = new Map;
     }
-    addHandler(e, t) {
-        const s = this._hookHandlers.get(e);
+    addHandler(t, e) {
+        const s = this._hookHandlers.get(t);
         if (s) {
-            s.push(t);
+            s.push(e);
         } else {
-            this._hookHandlers.set(e, [ t ]);
+            this._hookHandlers.set(t, [ e ]);
         }
     }
-    removeHandler(e, t) {
-        const s = this._hookHandlers.get(e);
+    removeHandler(t, e) {
+        const s = this._hookHandlers.get(t);
         if (s) {
-            const e = s.indexOf(t);
-            if (e !== -1) {
-                s.splice(e, 1);
+            const t = s.indexOf(e);
+            if (t !== -1) {
+                s.splice(t, 1);
             }
         }
     }
-    trigger(e, t) {
-        const s = this._hookHandlers.get(e);
+    trigger(t, e) {
+        const s = this._hookHandlers.get(t);
         if (s) {
             for (const i of s) {
                 try {
-                    i(t);
-                } catch (t) {
-                    this.emit("error", new Error(`Error in hook handler for event "${e}": ${t.message}`));
+                    i(e);
+                } catch (e) {
+                    this.emit("error", new Error(`Error in hook handler for event "${t}": ${e.message}`));
                 }
             }
         }
@@ -162,19 +164,19 @@ var o = class extends r {
     }
 };
 
-var a = o;
+var r = i;
 
-var n = class extends r {
+var o = class extends s {
     enabled=true;
     hits=0;
     misses=0;
     sets=0;
     deletes=0;
     errors=0;
-    constructor(e) {
+    constructor(t) {
         super();
-        if (e !== void 0) {
-            this.enabled = e;
+        if (t !== void 0) {
+            this.enabled = t;
         }
         this.reset();
     }
@@ -198,6 +200,15 @@ var n = class extends r {
             this.deletes++;
         }
     }
+    hitsOrMisses(t) {
+        for (const e of t) {
+            if (e === void 0) {
+                this.miss();
+            } else {
+                this.hit();
+            }
+        }
+    }
     reset() {
         this.hits = 0;
         this.misses = 0;
@@ -207,52 +218,57 @@ var n = class extends r {
     }
 };
 
-var h = n;
+var a = o;
 
-var l = (e => {
-    e["PRE_SET"] = "preSet";
-    e["POST_SET"] = "postSet";
-    e["PRE_GET"] = "preGet";
-    e["POST_GET"] = "postGet";
-    e["PRE_GET_MANY"] = "preGetMany";
-    e["POST_GET_MANY"] = "postGetMany";
-    e["PRE_DELETE"] = "preDelete";
-    e["POST_DELETE"] = "postDelete";
-    return e;
-})(l || {});
+var n = (t => {
+    t["PRE_SET"] = "preSet";
+    t["POST_SET"] = "postSet";
+    t["PRE_GET"] = "preGet";
+    t["POST_GET"] = "postGet";
+    t["PRE_GET_MANY"] = "preGetMany";
+    t["POST_GET_MANY"] = "postGetMany";
+    t["PRE_GET_RAW"] = "preGetRaw";
+    t["POST_GET_RAW"] = "postGetRaw";
+    t["PRE_GET_MANY_RAW"] = "preGetManyRaw";
+    t["POST_GET_MANY_RAW"] = "postGetManyRaw";
+    t["PRE_DELETE"] = "preDelete";
+    t["POST_DELETE"] = "postDelete";
+    return t;
+})(n || {});
 
-var c = [ "sqlite", "postgres", "mysql", "mongo", "redis", "valkey", "etcd" ];
+var h = [ "sqlite", "postgres", "mysql", "mongo", "redis", "valkey", "etcd" ];
 
-var f = class extends r {
+var l = class extends s {
     opts;
     iterator;
-    hooks=new a;
-    stats=new h(false);
+    hooks=new r;
+    stats=new a(false);
     _ttl;
     _namespace;
     _store=new Map;
-    _serialize=t;
-    _deserialize=s;
+    _serialize=defaultSerialize;
+    _deserialize=defaultDeserialize;
     _compression;
     _useKeyPrefix=true;
-    constructor(e, i) {
+    _throwOnErrors=false;
+    constructor(t, e) {
         super();
-        i ??= {};
         e ??= {};
+        t ??= {};
         this.opts = {
             namespace: "keyv",
-            serialize: t,
-            deserialize: s,
+            serialize: defaultSerialize,
+            deserialize: defaultDeserialize,
             emitErrors: true,
             store: new Map,
-            ...i
+            ...e
         };
-        if (e && e.get) {
-            this.opts.store = e;
+        if (t && t.get) {
+            this.opts.store = t;
         } else {
             this.opts = {
                 ...this.opts,
-                ...e
+                ...t
             };
         }
         this._store = this.opts.store ?? new Map;
@@ -267,7 +283,7 @@ var f = class extends r {
                 throw new Error("Invalid storage adapter");
             }
             if (typeof this._store.on === "function") {
-                this._store.on("error", (e => this.emit("error", e)));
+                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) {
@@ -285,24 +301,27 @@ var f = class extends r {
         if (this.opts.useKeyPrefix !== void 0) {
             this._useKeyPrefix = this.opts.useKeyPrefix;
         }
+        if (this.opts.throwOnErrors !== void 0) {
+            this._throwOnErrors = this.opts.throwOnErrors;
+        }
     }
     get store() {
         return this._store;
     }
-    set store(e) {
-        if (this._isValidStorageAdapter(e)) {
-            this._store = e;
-            this.opts.store = e;
-            if (typeof e.on === "function") {
-                e.on("error", (e => this.emit("error", e)));
+    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 e[Symbol.iterator] === "function" && e instanceof Map) {
-                this.iterator = this.generateIterator(e);
-            } else if ("iterator" in e && e.opts && this._checkIterableAdapter()) {
-                this.iterator = this.generateIterator(e.iterator.bind(e));
+            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");
@@ -311,187 +330,298 @@ var f = class extends r {
     get compression() {
         return this._compression;
     }
-    set compression(e) {
-        this._compression = e;
+    set compression(t) {
+        this._compression = t;
     }
     get namespace() {
         return this._namespace;
     }
-    set namespace(e) {
-        this._namespace = e;
-        this.opts.namespace = e;
-        this._store.namespace = e;
+    set namespace(t) {
+        this._namespace = t;
+        this.opts.namespace = t;
+        this._store.namespace = t;
         if (this.opts.store) {
-            this.opts.store.namespace = e;
+            this.opts.store.namespace = t;
         }
     }
     get ttl() {
         return this._ttl;
     }
-    set ttl(e) {
-        this.opts.ttl = e;
-        this._ttl = e;
+    set ttl(t) {
+        this.opts.ttl = t;
+        this._ttl = t;
     }
     get serialize() {
         return this._serialize;
     }
-    set serialize(e) {
-        this.opts.serialize = e;
-        this._serialize = e;
+    set serialize(t) {
+        this.opts.serialize = t;
+        this._serialize = t;
     }
     get deserialize() {
         return this._deserialize;
     }
-    set deserialize(e) {
-        this.opts.deserialize = e;
-        this._deserialize = e;
+    set deserialize(t) {
+        this.opts.deserialize = t;
+        this._deserialize = t;
     }
     get useKeyPrefix() {
         return this._useKeyPrefix;
     }
-    set useKeyPrefix(e) {
-        this._useKeyPrefix = e;
-        this.opts.useKeyPrefix = e;
+    set useKeyPrefix(t) {
+        this._useKeyPrefix = t;
+        this.opts.useKeyPrefix = t;
+    }
+    get throwOnErrors() {
+        return this._throwOnErrors;
+    }
+    set throwOnErrors(t) {
+        this._throwOnErrors = t;
+        this.opts.throwOnErrors = t;
     }
-    generateIterator(e) {
-        const t = async function*() {
-            for await (const [t, s] of typeof e === "function" ? e(this._store.namespace) : e) {
-                const e = await this.deserializeData(s);
-                if (this._useKeyPrefix && this._store.namespace && !t.includes(this._store.namespace)) {
+    generateIterator(t) {
+        const function_ = 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 e.expires === "number" && Date.now() > e.expires) {
-                    this.delete(t);
+                if (typeof t.expires === "number" && Date.now() > t.expires) {
+                    this.delete(e);
                     continue;
                 }
-                yield [ this._getKeyUnprefix(t), e.value ];
+                yield [ this._getKeyUnprefix(e), t.value ];
             }
         };
-        return t.bind(this);
+        return function_.bind(this);
     }
     _checkIterableAdapter() {
-        return c.includes(this._store.opts.dialect) || c.some((e => this._store.opts.url.includes(e)));
+        return h.includes(this._store.opts.dialect) || h.some((t => this._store.opts.url.includes(t)));
     }
-    _getKeyPrefix(e) {
+    _getKeyPrefix(t) {
         if (!this._useKeyPrefix) {
-            return e;
+            return t;
         }
         if (!this._namespace) {
-            return e;
+            return t;
         }
-        return `${this._namespace}:${e}`;
+        return `${this._namespace}:${t}`;
     }
-    _getKeyPrefixArray(e) {
+    _getKeyPrefixArray(t) {
         if (!this._useKeyPrefix) {
-            return e;
+            return t;
         }
         if (!this._namespace) {
-            return e;
+            return t;
         }
-        return e.map((e => `${this._namespace}:${e}`));
+        return t.map((t => `${this._namespace}:${t}`));
     }
-    _getKeyUnprefix(e) {
+    _getKeyUnprefix(t) {
         if (!this._useKeyPrefix) {
-            return e;
+            return t;
         }
-        return e.split(":").splice(1).join(":");
+        return t.split(":").splice(1).join(":");
     }
-    _isValidStorageAdapter(e) {
-        return e instanceof Map || typeof e.get === "function" && typeof e.set === "function" && typeof e.delete === "function" && typeof e.clear === "function";
+    _isValidStorageAdapter(t) {
+        return t instanceof Map || typeof t.get === "function" && typeof t.set === "function" && typeof t.delete === "function" && typeof t.clear === "function";
     }
-    async get(e, t) {
+    async get(t, e) {
         const {store: s} = this.opts;
-        const i = Array.isArray(e);
-        const r = i ? this._getKeyPrefixArray(e) : this._getKeyPrefix(e);
-        const o = e => typeof e.expires === "number" && Date.now() > e.expires;
+        const i = Array.isArray(t);
+        const r = i ? this._getKeyPrefixArray(t) : this._getKeyPrefix(t);
+        const isDataExpired = t => typeof t.expires === "number" && Date.now() > t.expires;
         if (i) {
-            if (t?.raw === true) {
-                return this.getMany(e, {
+            if (e?.raw === true) {
+                return this.getMany(t, {
                     raw: true
                 });
             }
-            return this.getMany(e, {
+            return this.getMany(t, {
                 raw: false
             });
         }
         this.hooks.trigger("preGet", {
             key: r
         });
-        const a = await s.get(r);
-        const n = typeof a === "string" || this.opts.compression ? await this.deserializeData(a) : a;
-        if (n === void 0 || n === null) {
+        let o;
+        try {
+            o = await s.get(r);
+        } catch (t) {
+            if (this.throwOnErrors) {
+                throw t;
+            }
+        }
+        const a = typeof o === "string" || this.opts.compression ? await this.deserializeData(o) : o;
+        if (a === void 0 || a === null) {
+            this.hooks.trigger("postGet", {
+                key: r,
+                value: void 0
+            });
             this.stats.miss();
             return void 0;
         }
-        if (o(n)) {
-            await this.delete(e);
+        if (isDataExpired(a)) {
+            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
+            value: a
         });
         this.stats.hit();
-        return t?.raw ? n : n.value;
+        return e?.raw ? a : a.value;
     }
-    async getMany(e, t) {
+    async getMany(t, e) {
         const {store: s} = this.opts;
-        const i = this._getKeyPrefixArray(e);
-        const r = e => typeof e.expires === "number" && Date.now() > e.expires;
+        const i = this._getKeyPrefixArray(t);
+        const isDataExpired = t => typeof t.expires === "number" && Date.now() > t.expires;
         this.hooks.trigger("preGetMany", {
             keys: i
         });
         if (s.getMany === void 0) {
-            const e = i.map((async e => {
-                const i = await s.get(e);
-                const o = typeof i === "string" || this.opts.compression ? await this.deserializeData(i) : i;
-                if (o === void 0 || o === null) {
+            const t = i.map((async t => {
+                const i = await s.get(t);
+                const r = typeof i === "string" || this.opts.compression ? await this.deserializeData(i) : i;
+                if (r === void 0 || r === null) {
                     return void 0;
                 }
-                if (r(o)) {
-                    await this.delete(e);
+                if (isDataExpired(r)) {
+                    await this.delete(t);
                     return void 0;
                 }
-                return t?.raw ? o : o.value;
+                return e?.raw ? r : r.value;
             }));
-            const o = await Promise.allSettled(e);
-            const a = o.map((e => e.value));
-            this.hooks.trigger("postGetMany", a);
-            if (a.length > 0) {
+            const r = await Promise.allSettled(t);
+            const o = r.map((t => t.value));
+            this.hooks.trigger("postGetMany", o);
+            if (o.length > 0) {
                 this.stats.hit();
             }
-            return a;
+            return o;
         }
-        const o = await s.getMany(i);
+        const r = await s.getMany(i);
+        const o = [];
         const a = [];
-        for (const s in o) {
-            let i = o[s];
+        for (const s in r) {
+            let i = r[s];
             if (typeof i === "string") {
                 i = await this.deserializeData(i);
             }
             if (i === void 0 || i === null) {
-                a.push(void 0);
+                o.push(void 0);
                 continue;
             }
-            if (r(i)) {
-                await this.delete(e[s]);
-                a.push(void 0);
+            if (isDataExpired(i)) {
+                a.push(t[s]);
+                o.push(void 0);
                 continue;
             }
-            const n = t?.raw ? i : i.value;
-            a.push(n);
+            const n = e?.raw ? i : i.value;
+            o.push(n);
         }
-        this.hooks.trigger("postGetMany", a);
         if (a.length > 0) {
+            await this.deleteMany(a);
+        }
+        this.hooks.trigger("postGetMany", o);
+        if (o.length > 0) {
             this.stats.hit();
         }
-        return a;
+        return o;
     }
-    async set(e, t, s) {
+    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;
+        }
+        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;
+        }
+        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 isDataExpired = t => typeof t.expires === "number" && Date.now() > t.expires;
+        for (const [t, e] of i.entries()) {
+            if (e !== void 0 && isDataExpired(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: e,
-            value: t,
+            key: t,
+            value: e,
             ttl: s
         };
         this.hooks.trigger("preSet", i);
@@ -513,13 +643,16 @@ var f = class extends r {
         const h = await this.serializeData(n);
         let l = true;
         try {
-            const e = await o.set(r, h, i.ttl);
-            if (typeof e === "boolean") {
-                l = e;
+            const t = await o.set(r, h, i.ttl);
+            if (typeof t === "boolean") {
+                l = t;
             }
-        } catch (e) {
+        } catch (t) {
             l = false;
-            this.emit("error", e);
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
         }
         this.hooks.trigger("postSet", {
             key: r,
@@ -529,63 +662,71 @@ var f = class extends r {
         this.stats.set();
         return l;
     }
-    async setMany(e) {
-        let t = [];
+    async setMany(t) {
+        let e = [];
         try {
-            if (this._store.setMany !== void 0) {
-                const s = await Promise.all(e.map((async ({key: e, value: t, ttl: s}) => {
+            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 t === "symbol") {
+                    if (typeof e === "symbol") {
                         this.emit("error", "symbol cannot be serialized");
                         throw new Error("symbol cannot be serialized");
                     }
                     const r = {
-                        value: t,
+                        value: e,
                         expires: i
                     };
                     const o = await this.serializeData(r);
+                    const a = this._getKeyPrefix(t);
                     return {
-                        key: e,
+                        key: a,
                         value: o,
                         ttl: s
                     };
                 })));
-                t = await this._store.setMany(s);
+                e = await this._store.setMany(s);
             }
-            const s = [];
-            for (const t of e) {
-                s.push(this.set(t.key, t.value, t.ttl));
-            }
-            const i = await Promise.allSettled(s);
-            t = i.map((e => e.value));
         } catch (s) {
             this.emit("error", s);
-            t = e.map((() => false));
+            if (this._throwOnErrors) {
+                throw s;
+            }
+            e = t.map((() => false));
         }
-        return t;
+        return e;
     }
-    async delete(e) {
-        const {store: t} = this.opts;
-        if (Array.isArray(e)) {
-            return this.deleteMany(e);
+    async delete(t) {
+        const {store: e} = this.opts;
+        if (Array.isArray(t)) {
+            return this.deleteMany(t);
         }
-        const s = this._getKeyPrefix(e);
+        const s = this._getKeyPrefix(t);
         this.hooks.trigger("preDelete", {
             key: s
         });
         let i = true;
         try {
-            const e = await t.delete(s);
-            if (typeof e === "boolean") {
-                i = e;
+            const t = await e.delete(s);
+            if (typeof t === "boolean") {
+                i = t;
             }
-        } catch (e) {
+        } catch (t) {
             i = false;
-            this.emit("error", e);
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
         }
         this.hooks.trigger("postDelete", {
             key: s,
@@ -594,69 +735,79 @@ var f = class extends r {
         this.stats.delete();
         return i;
     }
-    async deleteMany(e) {
+    async deleteMany(t) {
         try {
-            const {store: t} = this.opts;
-            const s = this._getKeyPrefixArray(e);
+            const {store: e} = this.opts;
+            const s = this._getKeyPrefixArray(t);
             this.hooks.trigger("preDelete", {
                 key: s
             });
-            if (t.deleteMany !== void 0) {
-                return await t.deleteMany(s);
+            if (e.deleteMany !== void 0) {
+                return await e.deleteMany(s);
             }
-            const i = s.map((async e => t.delete(e)));
-            const r = await Promise.allSettled(i);
-            const o = r.every((e => e.value === true));
+            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 (e) {
-            this.emit("error", e);
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
             return false;
         }
     }
     async clear() {
         this.emit("clear");
-        const {store: e} = this.opts;
+        const {store: t} = this.opts;
         try {
-            await e.clear();
-        } catch (e) {
-            this.emit("error", e);
+            await t.clear();
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
         }
     }
-    async has(e) {
-        if (Array.isArray(e)) {
-            return this.hasMany(e);
+    async has(t) {
+        if (Array.isArray(t)) {
+            return this.hasMany(t);
         }
-        const t = this._getKeyPrefix(e);
+        const e = this._getKeyPrefix(t);
         const {store: s} = this.opts;
         if (s.has !== void 0 && !(s instanceof Map)) {
-            return s.has(t);
+            return s.has(e);
         }
         let i;
         try {
-            i = await s.get(t);
-        } catch (e) {
-            this.emit("error", e);
+            i = await s.get(e);
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
+            }
+            return false;
         }
         if (i) {
-            const e = await this.deserializeData(i);
-            if (e) {
-                if (e.expires === void 0 || e.expires === null) {
+            const t = await this.deserializeData(i);
+            if (t) {
+                if (t.expires === void 0 || t.expires === null) {
                     return true;
                 }
-                return e.expires > Date.now();
+                return t.expires > Date.now();
             }
         }
         return false;
     }
-    async hasMany(e) {
-        const t = this._getKeyPrefixArray(e);
+    async hasMany(t) {
+        const e = this._getKeyPrefixArray(t);
         const {store: s} = this.opts;
         if (s.hasMany !== void 0) {
-            return s.hasMany(t);
+            return s.hasMany(e);
         }
         const i = [];
         for (const e of t) {
@@ -665,52 +816,52 @@ var f = class extends r {
         return i;
     }
     async disconnect() {
-        const {store: e} = this.opts;
+        const {store: t} = this.opts;
         this.emit("disconnect");
-        if (typeof e.disconnect === "function") {
-            return e.disconnect();
+        if (typeof t.disconnect === "function") {
+            return t.disconnect();
         }
     }
-    emit(e, ...t) {
-        if (e === "error" && !this.opts.emitErrors) {
+    emit(t, ...e) {
+        if (t === "error" && !this.opts.emitErrors) {
             return;
         }
-        super.emit(e, ...t);
+        super.emit(t, ...e);
     }
-    async serializeData(e) {
+    async serializeData(t) {
         if (!this._serialize) {
-            return e;
+            return t;
         }
         if (this._compression?.compress) {
             return this._serialize({
-                value: await this._compression.compress(e.value),
-                expires: e.expires
+                value: await this._compression.compress(t.value),
+                expires: t.expires
             });
         }
-        return this._serialize(e);
+        return this._serialize(t);
     }
-    async deserializeData(e) {
+    async deserializeData(t) {
         if (!this._deserialize) {
-            return e;
+            return t;
         }
-        if (this._compression?.decompress && typeof e === "string") {
-            const t = await this._deserialize(e);
+        if (this._compression?.decompress && typeof t === "string") {
+            const e = await this._deserialize(t);
             return {
-                value: await this._compression.decompress(t?.value),
-                expires: t?.expires
+                value: await this._compression.decompress(e?.value),
+                expires: e?.expires
             };
         }
-        if (typeof e === "string") {
-            return this._deserialize(e);
+        if (typeof t === "string") {
+            return this._deserialize(t);
         }
         return void 0;
     }
 };
 
-var p = f;
+var c = l;
 
-exports.Keyv = f;
+exports.Keyv = l;
 
-exports.defaultDeserialize = s;
+exports.defaultDeserialize = defaultDeserialize;
 
-exports.index_default = p;
+exports.index_default = c;