lakutata 2.0.80 → 2.0.82

package/src/components/cacher/Cacher.mjs

@@ -2,43 +2,45 @@ import { _ as e, a as t } from "../../../vendor/Package.1.mjs";
 
 import r from "events";
 
-import { K as s } from "../../../vendor/Package.67.mjs";
+import { H as s } from "../../../vendor/Package.66.mjs";
 
-import { Component as o } from "../../lib/core/Component.mjs";
+import { K as i } from "../../../vendor/Package.67.mjs";
 
-import { Configurable as i } from "../../decorators/di/Configurable.mjs";
+import { Component as n } from "../../lib/core/Component.mjs";
+
+import { Configurable as o } from "../../decorators/di/Configurable.mjs";
 
 import { As as a } from "../../lib/helpers/As.mjs";
 
-import { CreateFileCacheAdapter as n } from "./adapters/CreateFileCacheAdapter.mjs";
+import { CreateFileCacheAdapter as c } from "./adapters/CreateFileCacheAdapter.mjs";
 
-import { CreateRedisCacheAdapter as c } from "./adapters/CreateRedisCacheAdapter.mjs";
+import { CreateRedisCacheAdapter as l } from "./adapters/CreateRedisCacheAdapter.mjs";
 
-import { CreateMemcacheCacheAdapter as m } from "./adapters/CreateMemcacheCacheAdapter.mjs";
+import { CreateMemcacheCacheAdapter as h } from "./adapters/CreateMemcacheCacheAdapter.mjs";
 
-import { CreateMongoCacheAdapter as l } from "./adapters/CreateMongoCacheAdapter.mjs";
+import { CreateMongoCacheAdapter as m } from "./adapters/CreateMongoCacheAdapter.mjs";
 
-import { CreateSqliteCacheAdapter as p } from "./adapters/CreateSqliteCacheAdapter.mjs";
+import { CreateSqliteCacheAdapter as u } from "./adapters/CreateSqliteCacheAdapter.mjs";
 
-import { CreatePostgresCacheAdapter as h } from "./adapters/CreatePostgresCacheAdapter.mjs";
+import { CreatePostgresCacheAdapter as d } from "./adapters/CreatePostgresCacheAdapter.mjs";
 
-import { CreateMysqlCacheAdapter as d } from "./adapters/CreateMysqlCacheAdapter.mjs";
+import { CreateMysqlCacheAdapter as f } from "./adapters/CreateMysqlCacheAdapter.mjs";
 
-import { D as u } from "../../../vendor/Package.2.mjs";
+import { D as p } from "../../../vendor/Package.2.mjs";
 
 import { FileCacheOptions as y } from "./options/FileCacheOptions.mjs";
 
-import { RedisCacheOptions as f } from "./options/RedisCacheOptions.mjs";
+import { RedisCacheOptions as g } from "./options/RedisCacheOptions.mjs";
 
-import { MemcacheCacheOptions as j } from "./options/MemcacheCacheOptions.mjs";
+import { MemcacheCacheOptions as b } from "./options/MemcacheCacheOptions.mjs";
 
-import { MongoCacheOptions as b } from "./options/MongoCacheOptions.mjs";
+import { MongoCacheOptions as v } from "./options/MongoCacheOptions.mjs";
 
-import { SqliteCacheOptions as v } from "./options/SqliteCacheOptions.mjs";
+import { SqliteCacheOptions as _ } from "./options/SqliteCacheOptions.mjs";
 
-import { PostgresCacheOptions as g } from "./options/PostgresCacheOptions.mjs";
+import { PostgresCacheOptions as j } from "./options/PostgresCacheOptions.mjs";
 
-import { MysqlCacheOptions as k } from "./options/MysqlCacheOptions.mjs";
+import { MysqlCacheOptions as w } from "./options/MysqlCacheOptions.mjs";
 
 import "buffer";
 
@@ -134,10 +136,12 @@ import "os";
 
 import "path";
 
-import "stream";
-
 import "fs";
 
+import "../../../vendor/Package.10.mjs";
+
+import "stream";
+
 import "../../lib/ioc/Utils.mjs";
 
 import "../../lib/ioc/FunctionTokenizer.mjs";
@@ -180,15 +184,9 @@ import "../../lib/core/Provider.mjs";
 
 import "../../../vendor/Package.12.mjs";
 
-import "../../../vendor/Package.18.mjs";
-
-import "constants";
-
-import "../../../vendor/Package.15.mjs";
+import "fs/promises";
 
-import "assert";
-
-import "../../../vendor/Package.122.mjs";
+import "../../../vendor/Package.14.mjs";
 
 import "./lib/IsDriverPackageInstalled.mjs";
 
@@ -196,49 +194,537 @@ import "./exceptions/CacheDriverNotFoundException.mjs";
 
 import "../../lib/helpers/URLBuilder.mjs";
 
-var w = new Map;
+var S = class {
+    get name() {
+        return "crc32";
+    }
+    toHashSync(e) {
+        let t;
+        if (e instanceof Uint8Array) {
+            t = e;
+        } else if (e instanceof ArrayBuffer) {
+            t = new Uint8Array(e);
+        } else if (e instanceof DataView) {
+            t = new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+        } else {
+            const r = e;
+            t = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+        }
+        const r = 3988292384;
+        let s = 4294967295;
+        for (let e = 0; e < t.length; e++) {
+            s = s ^ t[e];
+            for (let e = 0; e < 8; e++) {
+                s = s >>> 1 ^ r & -(s & 1);
+            }
+        }
+        s = (s ^ 4294967295) >>> 0;
+        const i = s.toString(16).padStart(8, "0");
+        return i;
+    }
+    async toHash(e) {
+        return this.toHashSync(e);
+    }
+};
+
+var A = class {
+    _algorithm="SHA-256";
+    constructor(e) {
+        if (e?.algorithm) {
+            this._algorithm = e?.algorithm;
+        }
+    }
+    get name() {
+        return this._algorithm;
+    }
+    async toHash(e) {
+        const t = await crypto.subtle.digest(this._algorithm, e);
+        const r = Array.from(new Uint8Array(t));
+        const s = r.map((e => e.toString(16).padStart(2, "0"))).join("");
+        return s;
+    }
+};
+
+var k = class {
+    get name() {
+        return "djb2";
+    }
+    toHashSync(e) {
+        let t;
+        if (e instanceof Uint8Array) {
+            t = e;
+        } else if (e instanceof ArrayBuffer) {
+            t = new Uint8Array(e);
+        } else if (e instanceof DataView) {
+            t = new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+        } else {
+            const r = e;
+            t = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+        }
+        let r = 5381;
+        for (let e = 0; e < t.length; e++) {
+            r = (r << 5) + r + t[e];
+            r = r >>> 0;
+        }
+        const s = r.toString(16).padStart(8, "0");
+        return s;
+    }
+    async toHash(e) {
+        return this.toHashSync(e);
+    }
+};
+
+var x = class {
+    get name() {
+        return "fnv1";
+    }
+    toHashSync(e) {
+        let t;
+        if (e instanceof Uint8Array) {
+            t = e;
+        } else if (e instanceof ArrayBuffer) {
+            t = new Uint8Array(e);
+        } else if (e instanceof DataView) {
+            t = new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+        } else {
+            const r = e;
+            t = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+        }
+        const r = 2166136261;
+        const s = 16777619;
+        let i = r;
+        for (let e = 0; e < t.length; e++) {
+            i = i * s;
+            i = i ^ t[e];
+            i = i >>> 0;
+        }
+        const n = i.toString(16).padStart(8, "0");
+        return n;
+    }
+    async toHash(e) {
+        return this.toHashSync(e);
+    }
+};
+
+var C = class {
+    _seed;
+    constructor(e = 0) {
+        this._seed = e >>> 0;
+    }
+    get name() {
+        return "murmer";
+    }
+    get seed() {
+        return this._seed;
+    }
+    toHashSync(e) {
+        let t;
+        if (e instanceof Uint8Array) {
+            t = e;
+        } else if (e instanceof ArrayBuffer) {
+            t = new Uint8Array(e);
+        } else if (e instanceof DataView) {
+            t = new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+        } else {
+            const r = e;
+            t = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+        }
+        const r = 3432918353;
+        const s = 461845907;
+        const i = t.length;
+        const n = Math.floor(i / 4);
+        let o = this._seed;
+        for (let e = 0; e < n; e++) {
+            const i = e * 4;
+            let n = t[i] & 255 | (t[i + 1] & 255) << 8 | (t[i + 2] & 255) << 16 | (t[i + 3] & 255) << 24;
+            n = this._imul(n, r);
+            n = this._rotl32(n, 15);
+            n = this._imul(n, s);
+            o ^= n;
+            o = this._rotl32(o, 13);
+            o = this._imul(o, 5) + 3864292196;
+        }
+        const a = n * 4;
+        let c = 0;
+        switch (i & 3) {
+          case 3:
+            c ^= (t[a + 2] & 255) << 16;
+
+          case 2:
+            c ^= (t[a + 1] & 255) << 8;
+
+          case 1:
+            c ^= t[a] & 255;
+            c = this._imul(c, r);
+            c = this._rotl32(c, 15);
+            c = this._imul(c, s);
+            o ^= c;
+        }
+        o ^= i;
+        o ^= o >>> 16;
+        o = this._imul(o, 2246822507);
+        o ^= o >>> 13;
+        o = this._imul(o, 3266489909);
+        o ^= o >>> 16;
+        o = o >>> 0;
+        const l = o.toString(16).padStart(8, "0");
+        return l;
+    }
+    async toHash(e) {
+        return this.toHashSync(e);
+    }
+    _imul(e, t) {
+        if (Math.imul) {
+            return Math.imul(e, t);
+        }
+        const r = e >>> 16 & 65535;
+        const s = e & 65535;
+        const i = t >>> 16 & 65535;
+        const n = t & 65535;
+        return s * n + (r * n + s * i << 16 >>> 0) | 0;
+    }
+    _rotl32(e, t) {
+        return e << t | e >>> 32 - t;
+    }
+};
+
+var P = class {
+    _providers=new Map;
+    _getFuzzy=true;
+    constructor(e) {
+        if (e?.providers) {
+            this.loadProviders(e?.providers);
+        }
+        if (e?.getFuzzy !== void 0) {
+            this._getFuzzy = Boolean(e?.getFuzzy);
+        }
+    }
+    loadProviders(e) {
+        for (const t of e) {
+            this._providers.set(t.name, t);
+        }
+    }
+    get providers() {
+        return this._providers;
+    }
+    set providers(e) {
+        this._providers = e;
+    }
+    get names() {
+        return Array.from(this._providers.keys());
+    }
+    get(e, t) {
+        const r = t?.fuzzy ?? this._getFuzzy;
+        e = e.trim();
+        let s = this._providers.get(e);
+        if (s === void 0 && r === true) {
+            e = e.toLowerCase();
+            s = this._providers.get(e);
+        }
+        if (s === void 0 && r === true) {
+            e = e.replaceAll("-", "");
+            s = this._providers.get(e);
+        }
+        return s;
+    }
+    add(e) {
+        this._providers.set(e.name, e);
+    }
+    remove(e) {
+        return this._providers.delete(e);
+    }
+};
+
+var z = class extends s {
+    _parse=JSON.parse;
+    _stringify=JSON.stringify;
+    _providers=new P;
+    _defaultAlgorithm="SHA-256";
+    _defaultAlgorithmSync="djb2";
+    constructor(e) {
+        super(e);
+        if (e?.parse) {
+            this._parse = e.parse;
+        }
+        if (e?.stringify) {
+            this._stringify = e.stringify;
+        }
+        if (e?.defaultAlgorithm) {
+            this._defaultAlgorithm = e.defaultAlgorithm;
+        }
+        if (e?.defaultAlgorithmSync) {
+            this._defaultAlgorithmSync = e.defaultAlgorithmSync;
+        }
+        this.loadProviders(e?.providers, {
+            includeBase: e?.includeBase ?? true
+        });
+    }
+    get parse() {
+        return this._parse;
+    }
+    set parse(e) {
+        this._parse = e;
+    }
+    get stringify() {
+        return this._stringify;
+    }
+    set stringify(e) {
+        this._stringify = e;
+    }
+    get providers() {
+        return this._providers;
+    }
+    set providers(e) {
+        this._providers = e;
+    }
+    get names() {
+        return this._providers.names;
+    }
+    get defaultAlgorithm() {
+        return this._defaultAlgorithm;
+    }
+    set defaultAlgorithm(e) {
+        this._defaultAlgorithm = e;
+    }
+    get defaultAlgorithmSync() {
+        return this._defaultAlgorithmSync;
+    }
+    set defaultAlgorithmSync(e) {
+        this._defaultAlgorithmSync = e;
+    }
+    async toHash(e, t) {
+        const r = {
+            data: e,
+            algorithm: t?.algorithm ?? this._defaultAlgorithm,
+            maxLength: t?.maxLength
+        };
+        await this.beforeHook("toHash", r);
+        const s = this._stringify(r.data);
+        const i = new TextEncoder;
+        const n = i.encode(s);
+        let o = this._providers.get(r.algorithm);
+        if (!o) {
+            o = new A({
+                algorithm: this._defaultAlgorithm
+            });
+        }
+        let a = await o.toHash(n);
+        if (t?.maxLength && a.length > t?.maxLength) {
+            a = a.substring(0, t.maxLength);
+        }
+        const c = {
+            hash: a,
+            data: r.data,
+            algorithm: r.algorithm
+        };
+        await this.afterHook("toHash", c);
+        return c.hash;
+    }
+    async toNumber(e, t = {}) {
+        const {min: r = 0, max: s = 100, algorithm: i = this._defaultAlgorithm, hashLength: n = 16} = t;
+        if (r > s) {
+            throw new Error("min cannot be greater than max");
+        }
+        const o = await this.toHash(e, {
+            algorithm: i,
+            maxLength: n
+        });
+        const a = Number.parseInt(o, 16);
+        const c = s - r + 1;
+        const l = r + a % c;
+        return l;
+    }
+    toHashSync(e, t) {
+        const r = {
+            data: e,
+            algorithm: t?.algorithm ?? this._defaultAlgorithmSync,
+            maxLength: t?.maxLength
+        };
+        this.beforeHook("toHashSync", r);
+        const s = r.algorithm;
+        const i = this._stringify(r.data);
+        const n = new TextEncoder;
+        const o = n.encode(i);
+        const a = this._providers.get(s);
+        if (!a) {
+            throw new Error(`Hash provider '${s}' not found`);
+        }
+        if (!a.toHashSync) {
+            throw new Error(`Hash provider '${s}' does not support synchronous hashing. Use toHash() instead or choose a different algorithm (djb2, fnv1, murmer, crc32).`);
+        }
+        let c = a.toHashSync(o);
+        if (t?.maxLength && c.length > t?.maxLength) {
+            c = c.substring(0, t.maxLength);
+        }
+        const l = {
+            hash: c,
+            data: r.data,
+            algorithm: r.algorithm
+        };
+        this.afterHook("toHashSync", l);
+        return l.hash;
+    }
+    toNumberSync(e, t = {}) {
+        const {min: r = 0, max: s = 100, algorithm: i = this._defaultAlgorithmSync, hashLength: n = 16} = t;
+        if (r > s) {
+            throw new Error("min cannot be greater than max");
+        }
+        const o = this.toHashSync(e, {
+            algorithm: i,
+            maxLength: n
+        });
+        const a = Number.parseInt(o, 16);
+        const c = s - r + 1;
+        const l = r + a % c;
+        return l;
+    }
+    loadProviders(e, t = {
+        includeBase: true
+    }) {
+        if (e) {
+            for (const t of e) {
+                this._providers.add(t);
+            }
+        }
+        if (t.includeBase) {
+            this.providers.add(new A({
+                algorithm: "SHA-256"
+            }));
+            this.providers.add(new A({
+                algorithm: "SHA-384"
+            }));
+            this.providers.add(new A({
+                algorithm: "SHA-512"
+            }));
+            this.providers.add(new S);
+            this.providers.add(new k);
+            this.providers.add(new x);
+            this.providers.add(new C);
+        }
+    }
+};
+
+var shorthandToMilliseconds = e => {
+    let t;
+    if (e === void 0) {
+        return void 0;
+    }
+    if (typeof e === "number") {
+        t = e;
+    } else {
+        if (typeof e !== "string") {
+            return void 0;
+        }
+        e = e.trim();
+        if (Number.isNaN(Number(e))) {
+            const r = /^([\d.]+)\s*(ms|s|m|h|hr|d)$/i.exec(e);
+            if (!r) {
+                throw new Error(`Unsupported time format: "${e}". Use 'ms', 's', 'm', 'h', 'hr', or 'd'.`);
+            }
+            const [, s, i] = r;
+            const n = Number.parseFloat(s);
+            const o = i.toLowerCase();
+            switch (o) {
+              case "ms":
+                {
+                    t = n;
+                    break;
+                }
+
+              case "s":
+                {
+                    t = n * 1e3;
+                    break;
+                }
+
+              case "m":
+                {
+                    t = n * 1e3 * 60;
+                    break;
+                }
+
+              case "h":
+                {
+                    t = n * 1e3 * 60 * 60;
+                    break;
+                }
+
+              case "hr":
+                {
+                    t = n * 1e3 * 60 * 60;
+                    break;
+                }
+
+              case "d":
+                {
+                    t = n * 1e3 * 60 * 60 * 24;
+                    break;
+                }
+
+              default:
+                {
+                    t = Number(e);
+                }
+            }
+        } else {
+            t = Number(e);
+        }
+    }
+    return t;
+};
+
+var shorthandToTime = (e, t) => {
+    t ??= new Date;
+    const r = shorthandToMilliseconds(e);
+    if (r === void 0) {
+        return t.getTime();
+    }
+    return t.getTime() + r;
+};
+
+var H = new Map;
 
-function P(e) {
-    return w.has(e);
+function hasKey(e) {
+    return H.has(e);
 }
 
-function C(e) {
-    w.set(e, []);
+function addKey(e) {
+    H.set(e, []);
 }
 
-function S(e) {
-    w.delete(e);
+function removeKey(e) {
+    H.delete(e);
 }
 
-function x(e, t) {
-    const r = A(e);
+function addCallbackToKey(e, t) {
+    const r = getCallbacksByKey(e);
     r.push(t);
-    w.set(e, r);
+    H.set(e, r);
 }
 
-function A(e) {
-    return w.get(e) ?? [];
+function getCallbacksByKey(e) {
+    return H.get(e) ?? [];
 }
 
-async function I(e) {
+async function enqueue(e) {
     return new Promise(((t, r) => {
         const s = {
             resolve: t,
             reject: r
         };
-        x(e, s);
+        addCallbackToKey(e, s);
     }));
 }
 
-function M(e) {
-    const t = A(e);
-    S(e);
+function dequeue(e) {
+    const t = getCallbacksByKey(e);
+    removeKey(e);
     return t;
 }
 
-function O(e) {
+function coalesce(e) {
     const {key: t, error: r, result: s} = e;
-    for (const e of M(t)) {
+    for (const e of dequeue(t)) {
         if (r) {
             e.reject(r);
         } else {
@@ -247,40 +733,422 @@ function O(e) {
     }
 }
 
-async function L(e, t) {
-    if (!P(e)) {
-        C(e);
+async function coalesceAsync(e, t) {
+    if (!hasKey(e)) {
+        addKey(e);
         try {
             const r = await Promise.resolve(t());
-            O({
+            coalesce({
                 key: e,
                 result: r
             });
             return r;
         } catch (t) {
-            O({
+            coalesce({
                 key: e,
                 error: t
             });
             throw t;
         }
     }
-    return I(e);
+    return enqueue(e);
+}
+
+var O = (e => {
+    e["SHA256"] = "SHA-256";
+    e["SHA384"] = "SHA-384";
+    e["SHA512"] = "SHA-512";
+    e["DJB2"] = "djb2";
+    e["FNV1"] = "fnv1";
+    e["MURMER"] = "murmer";
+    e["CRC32"] = "crc32";
+    return e;
+})(O || {});
+
+async function hash(e, t = {
+    algorithm: "SHA-256",
+    serialize: JSON.stringify
+}) {
+    const r = t?.algorithm ?? "SHA-256";
+    const s = t?.serialize ?? JSON.stringify;
+    const i = s(e);
+    const n = new z;
+    return n.toHash(i, {
+        algorithm: r
+    });
+}
+
+function hashSync(e, t = {
+    algorithm: "djb2",
+    serialize: JSON.stringify
+}) {
+    const r = t?.algorithm ?? "djb2";
+    const s = t?.serialize ?? JSON.stringify;
+    const i = s(e);
+    const n = new z;
+    return n.toHashSync(i, {
+        algorithm: r
+    });
+}
+
+async function hashToNumber(e, t = {
+    min: 0,
+    max: 10,
+    algorithm: "SHA-256",
+    serialize: JSON.stringify
+}) {
+    const r = t?.min ?? 0;
+    const s = t?.max ?? 10;
+    const i = t?.algorithm ?? "SHA-256";
+    const n = t?.serialize ?? JSON.stringify;
+    const o = t?.hashLength ?? 16;
+    if (r >= s) {
+        throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
+    }
+    const a = n(e);
+    const c = new z;
+    return c.toNumber(a, {
+        algorithm: i,
+        min: r,
+        max: s,
+        hashLength: o
+    });
 }
 
-function T(e) {
+function hashToNumberSync(e, t = {
+    min: 0,
+    max: 10,
+    algorithm: "djb2",
+    serialize: JSON.stringify
+}) {
+    const r = t?.min ?? 0;
+    const s = t?.max ?? 10;
+    const i = t?.algorithm ?? "djb2";
+    const n = t?.serialize ?? JSON.stringify;
+    const o = t?.hashLength ?? 16;
+    if (r >= s) {
+        throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
+    }
+    const a = n(e);
+    const c = new z;
+    return c.toNumberSync(a, {
+        algorithm: i,
+        min: r,
+        max: s,
+        hashLength: o
+    });
+}
+
+function isKeyvInstance(e) {
+    if (e === null || e === void 0) {
+        return false;
+    }
+    if (e instanceof i) {
+        return true;
+    }
+    const t = [ "generateIterator", "get", "getMany", "set", "setMany", "delete", "deleteMany", "has", "hasMany", "clear", "disconnect", "serialize", "deserialize" ];
+    return t.every((t => typeof e[t] === "function"));
+}
+
+function isObject(e) {
     return e !== null && typeof e === "object" && !Array.isArray(e);
 }
 
-function _(e, ...t) {
+function lessThan(e, t) {
+    return typeof e === "number" && typeof t === "number" ? e < t : false;
+}
+
+function wrapSync(e, t) {
+    const {ttl: r, keyPrefix: s, cache: i, serialize: n} = t;
+    return (...o) => {
+        let a = createWrapKey(e, o, {
+            keyPrefix: s,
+            serialize: n
+        });
+        if (t.createKey) {
+            a = t.createKey(e, o, t);
+        }
+        let c = i.get(a);
+        if (c === void 0) {
+            try {
+                c = e(...o);
+                i.set(a, c, r);
+            } catch (e) {
+                i.emit("error", e);
+                if (t.cacheErrors) {
+                    i.set(a, e, r);
+                }
+            }
+        }
+        return c;
+    };
+}
+
+async function getOrSet(e, t, r) {
+    const s = typeof e === "function" ? e(r) : e;
+    let i = await r.cache.get(s);
+    if (i === void 0) {
+        const e = r.cacheId ?? "default";
+        const n = `${e}::${s}`;
+        i = await coalesceAsync(n, (async () => {
+            try {
+                const e = await t();
+                await r.cache.set(s, e, r.ttl);
+                return e;
+            } catch (e) {
+                r.cache.emit("error", e);
+                if (r.cacheErrors) {
+                    await r.cache.set(s, e, r.ttl);
+                }
+                if (r.throwErrors) {
+                    throw e;
+                }
+            }
+        }));
+    }
+    return i;
+}
+
+function wrap(e, t) {
+    const {keyPrefix: r, serialize: s} = t;
+    return async (...i) => {
+        let n = createWrapKey(e, i, {
+            keyPrefix: r,
+            serialize: s
+        });
+        if (t.createKey) {
+            n = t.createKey(e, i, t);
+        }
+        return getOrSet(n, (async () => e(...i)), t);
+    };
+}
+
+function createWrapKey(e, t, r) {
+    const {keyPrefix: s, serialize: i} = r || {};
+    if (!s) {
+        return `${e.name}::${hashSync(t, {
+            serialize: i
+        })}`;
+    }
+    return `${s}::${e.name}::${hashSync(t, {
+        serialize: i
+    })}`;
+}
+
+function runIfFn(e, ...t) {
     return typeof e === "function" ? e(...t) : e;
 }
 
-function D(e, t) {
-    return typeof e === "number" && typeof t === "number" ? e < t : false;
+var sleep = async e => new Promise((t => setTimeout(t, e)));
+
+var L = class {
+    _hits=0;
+    _misses=0;
+    _gets=0;
+    _sets=0;
+    _deletes=0;
+    _clears=0;
+    _vsize=0;
+    _ksize=0;
+    _count=0;
+    _enabled=false;
+    constructor(e) {
+        if (e?.enabled) {
+            this._enabled = e.enabled;
+        }
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(e) {
+        this._enabled = e;
+    }
+    get hits() {
+        return this._hits;
+    }
+    get misses() {
+        return this._misses;
+    }
+    get gets() {
+        return this._gets;
+    }
+    get sets() {
+        return this._sets;
+    }
+    get deletes() {
+        return this._deletes;
+    }
+    get clears() {
+        return this._clears;
+    }
+    get vsize() {
+        return this._vsize;
+    }
+    get ksize() {
+        return this._ksize;
+    }
+    get count() {
+        return this._count;
+    }
+    incrementHits() {
+        if (!this._enabled) {
+            return;
+        }
+        this._hits++;
+    }
+    incrementMisses() {
+        if (!this._enabled) {
+            return;
+        }
+        this._misses++;
+    }
+    incrementGets() {
+        if (!this._enabled) {
+            return;
+        }
+        this._gets++;
+    }
+    incrementSets() {
+        if (!this._enabled) {
+            return;
+        }
+        this._sets++;
+    }
+    incrementDeletes() {
+        if (!this._enabled) {
+            return;
+        }
+        this._deletes++;
+    }
+    incrementClears() {
+        if (!this._enabled) {
+            return;
+        }
+        this._clears++;
+    }
+    incrementVSize(e) {
+        if (!this._enabled) {
+            return;
+        }
+        this._vsize += this.roughSizeOfObject(e);
+    }
+    decreaseVSize(e) {
+        if (!this._enabled) {
+            return;
+        }
+        this._vsize -= this.roughSizeOfObject(e);
+    }
+    incrementKSize(e) {
+        if (!this._enabled) {
+            return;
+        }
+        this._ksize += this.roughSizeOfString(e);
+    }
+    decreaseKSize(e) {
+        if (!this._enabled) {
+            return;
+        }
+        this._ksize -= this.roughSizeOfString(e);
+    }
+    incrementCount() {
+        if (!this._enabled) {
+            return;
+        }
+        this._count++;
+    }
+    decreaseCount() {
+        if (!this._enabled) {
+            return;
+        }
+        this._count--;
+    }
+    setCount(e) {
+        if (!this._enabled) {
+            return;
+        }
+        this._count = e;
+    }
+    roughSizeOfString(e) {
+        return e.length * 2;
+    }
+    roughSizeOfObject(e) {
+        const t = [];
+        const r = [ e ];
+        let s = 0;
+        while (r.length > 0) {
+            const e = r.pop();
+            if (typeof e === "boolean") {
+                s += 4;
+            } else if (typeof e === "string") {
+                s += e.length * 2;
+            } else if (typeof e === "number") {
+                s += 8;
+            } else {
+                if (e === null || e === void 0) {
+                    s += 4;
+                    continue;
+                }
+                if (t.includes(e)) {
+                    continue;
+                }
+                t.push(e);
+                for (const t in e) {
+                    s += t.length * 2;
+                    r.push(e[t]);
+                }
+            }
+        }
+        return s;
+    }
+    reset() {
+        this._hits = 0;
+        this._misses = 0;
+        this._gets = 0;
+        this._sets = 0;
+        this._deletes = 0;
+        this._clears = 0;
+        this._vsize = 0;
+        this._ksize = 0;
+        this._count = 0;
+    }
+    resetStoreValues() {
+        this._vsize = 0;
+        this._ksize = 0;
+        this._count = 0;
+    }
+};
+
+function getTtlFromExpires(e) {
+    if (e === void 0 || e === null) {
+        return void 0;
+    }
+    const t = Date.now();
+    if (e < t) {
+        return void 0;
+    }
+    return e - t;
 }
 
-var E = class {
+function getCascadingTtl(e, t, r) {
+    return r ?? t ?? shorthandToMilliseconds(e);
+}
+
+function calculateTtlFromExpiration(e, t) {
+    const r = getTtlFromExpires(t);
+    const s = e ? Date.now() + e : void 0;
+    if (r === void 0) {
+        return e;
+    }
+    if (s === void 0) {
+        return r;
+    }
+    if (t && t > s) {
+        return e;
+    }
+    return r;
+}
+
+var I = class {
     opts;
     namespace;
     _cache;
@@ -328,19 +1196,21 @@ var E = class {
     }
 };
 
-var B = e => {
+var _storeLabel = e => e === 0 ? "primary" : `secondary:${e - 1}`;
+
+var createCache = e => {
     const t = new r;
-    const o = new s;
-    o.serialize = void 0;
-    o.deserialize = void 0;
-    const i = e?.stores?.length ? e.stores : [ o ];
-    const a = e?.nonBlocking ?? false;
-    const n = e?.cacheId ?? Math.random().toString(36).slice(2);
-    const c = async e => {
+    const s = new i;
+    s.serialize = void 0;
+    s.deserialize = void 0;
+    const n = e?.stores?.length ? e.stores : [ s ];
+    const o = e?.nonBlocking ?? false;
+    const a = e?.cacheId ?? Math.random().toString(36).slice(2);
+    const get = async e => {
         let r;
-        if (a) {
+        if (o) {
             try {
-                r = await Promise.race(i.map((async t => t.get(e))));
+                r = await Promise.race(n.map((async t => t.get(e))));
                 if (r === void 0) {
                     return void 0;
                 }
@@ -351,40 +1221,79 @@ var B = e => {
                 });
             }
         } else {
-            for (const s of i) {
+            for (let s = 0; s < n.length; s++) {
+                const i = n[s];
                 try {
-                    const o = await s.get(e);
-                    if (o !== void 0) {
-                        r = o;
+                    const n = await i.get(e);
+                    if (n !== void 0) {
+                        r = n;
                         t.emit("get", {
                             key: e,
-                            value: r
+                            value: r,
+                            store: _storeLabel(s)
                         });
                         break;
                     }
                 } catch (r) {
                     t.emit("get", {
                         key: e,
-                        error: r
+                        error: r,
+                        store: _storeLabel(s)
                     });
                 }
             }
         }
         return r;
     };
-    const m = async e => {
-        const t = [];
-        for (const r of e) {
-            const e = await c(r);
-            t.push(e);
+    const mget = async e => {
+        let r = e.map((() => void 0));
+        if (o) {
+            try {
+                r = await Promise.race(n.map((async t => t.getMany(e))));
+            } catch (r) {
+                t.emit("mget", {
+                    keys: e,
+                    error: r
+                });
+            }
+        } else {
+            for (const s of n) {
+                try {
+                    const t = r.map(((t, r) => t === void 0 ? {
+                        originalIndex: r,
+                        key: e[r]
+                    } : void 0)).filter((e => e !== void 0));
+                    if (t.length === 0) {
+                        break;
+                    }
+                    const i = t.map((e => e.key));
+                    const n = await s.getMany(i);
+                    for (const [e, s] of n.entries()) {
+                        if (s === void 0) {
+                            continue;
+                        }
+                        const {originalIndex: i} = t[e];
+                        r[i] = s;
+                    }
+                } catch (r) {
+                    t.emit("mget", {
+                        keys: e,
+                        error: r
+                    });
+                }
+            }
         }
-        return t;
+        t.emit("mget", {
+            keys: e,
+            values: r
+        });
+        return r;
     };
-    const l = async e => {
+    const ttl = async e => {
         let r;
-        if (a) {
+        if (o) {
             try {
-                r = await Promise.race(i.map((async t => t.get(e, {
+                r = await Promise.race(n.map((async t => t.get(e, {
                     raw: true
                 }))));
                 if (r === void 0) {
@@ -397,13 +1306,13 @@ var B = e => {
                 });
             }
         } else {
-            for (const s of i) {
+            for (const s of n) {
                 try {
-                    const o = await s.get(e, {
+                    const i = await s.get(e, {
                         raw: true
                     });
-                    if (o !== void 0) {
-                        r = o;
+                    if (i !== void 0) {
+                        r = i;
                         t.emit("ttl", {
                             key: e,
                             value: r
@@ -423,72 +1332,77 @@ var B = e => {
         }
         return void 0;
     };
-    const p = async (r, s, o, i) => {
+    const set = async (r, s, i, n) => {
         try {
-            if (a) {
-                Promise.all(r.map((async t => t.set(s, o, i ?? e?.ttl))));
+            const a = r.map((async (r, o) => {
+                await r.set(s, i, n ?? e?.ttl);
                 t.emit("set", {
                     key: s,
-                    value: o
+                    value: i,
+                    store: _storeLabel(o)
                 });
-                return o;
+            }));
+            if (o) {
+                Promise.all(a);
+                t.emit("set", {
+                    key: s,
+                    value: i
+                });
+                return i;
             }
-            await Promise.all(r.map((async t => t.set(s, o, i ?? e?.ttl))));
+            await Promise.all(a);
             t.emit("set", {
                 key: s,
-                value: o
+                value: i
             });
-            return o;
+            return i;
         } catch (e) {
             t.emit("set", {
                 key: s,
-                value: o,
+                value: i,
                 error: e
             });
             return Promise.reject(e);
         }
     };
-    const h = async (e, r) => {
-        const s = r.map((({key: e, value: t, ttl: r}) => ({
-            key: e,
-            value: t,
-            ttl: r
+    const mset = async (r, s) => {
+        const i = s.map((({key: t, value: r, ttl: s}) => ({
+            key: t,
+            value: r,
+            ttl: s ?? e?.ttl
         })));
         try {
-            const s = [];
-            for (const t of r) {
-                s.push(...e.map((async e => e.set(t.key, t.value, t.ttl))));
-            }
-            if (a) {
-                Promise.all(s);
+            const e = r.map((async e => e.setMany(i)));
+            if (o) {
+                Promise.all(e);
                 t.emit("mset", {
-                    list: r
+                    list: i
                 });
-                return r;
+                return i;
             }
-            await Promise.all(s);
+            await Promise.all(e);
             t.emit("mset", {
-                list: r
+                list: i
             });
-            return r;
+            return i;
         } catch (e) {
             t.emit("mset", {
-                list: r,
+                list: i,
                 error: e
             });
             return Promise.reject(e);
         }
     };
-    const d = async e => {
+    const del = async e => {
         try {
-            if (a) {
-                Promise.all(i.map((async t => t.delete(e))));
+            if (o) {
+                Promise.all(n.map((async t => t.delete(e))));
                 t.emit("del", {
                     key: e
                 });
                 return true;
             }
-            await Promise.all(i.map((async t => t.delete(e))));
+            await Promise.all(n.map((async t => t.delete(e))));
             t.emit("del", {
                 key: e
             });
@@ -501,13 +1415,13 @@ var B = e => {
             return Promise.reject(r);
         }
     };
-    const u = async e => {
+    const mdel = async e => {
         try {
             const r = [];
             for (const t of e) {
-                r.push(...i.map((async e => e.delete(t))));
+                r.push(...n.map((async e => e.delete(t))));
             }
-            if (a) {
+            if (o) {
                 Promise.all(r);
                 t.emit("mdel", {
                     keys: e
@@ -527,14 +1441,14 @@ var B = e => {
             return Promise.reject(r);
         }
     };
-    const y = async () => {
+    const clear = async () => {
         try {
-            if (a) {
-                Promise.all(i.map((async e => e.clear())));
+            if (o) {
+                Promise.all(n.map((async e => e.clear())));
                 t.emit("clear");
                 return true;
             }
-            await Promise.all(i.map((async e => e.clear())));
+            await Promise.all(n.map((async e => e.clear())));
             t.emit("clear");
             return true;
         } catch (e) {
@@ -542,26 +1456,26 @@ var B = e => {
             return Promise.reject(e);
         }
     };
-    const f = async (r, s, o, a) => L(`${n}::${r}`, (async () => {
+    const wrap = async (r, s, i, o) => coalesceAsync(`${a}::${r}`, (async () => {
         let c;
+        let l;
+        let h = 0;
         let m;
-        let l = 0;
-        let h;
-        const {ttl: d, refreshThreshold: u, raw: y} = T(o) ? o : {
-            ttl: o,
-            refreshThreshold: a
+        const {ttl: u, refreshThreshold: d, raw: f} = isObject(i) ? i : {
+            ttl: i,
+            refreshThreshold: o
         };
-        const f = t => _(d, t) ?? e?.ttl;
-        for (;l < i.length; l++) {
+        const resolveTtl = t => runIfFn(u, t) ?? e?.ttl;
+        for (;h < n.length; h++) {
             try {
-                const e = await i[l].get(r, {
+                const e = await n[h].get(r, {
                     raw: true
                 });
                 if (e !== void 0) {
                     c = e.value;
-                    m = e;
+                    l = e;
                     if (typeof e.expires === "number") {
-                        h = Math.max(0, e.expires - Date.now());
+                        m = Math.max(0, e.expires - Date.now());
                     }
                     break;
                 }
@@ -569,18 +1483,18 @@ var B = e => {
         }
         if (c === void 0) {
             const e = await s();
-            const t = f(e);
-            await p(i, r, e, t);
-            return y ? {
+            const t = resolveTtl(e);
+            await set(n, r, e, t);
+            return f ? {
                 value: e,
                 expires: Date.now() + t
             } : e;
         }
-        const j = D(h, _(u, c) ?? e?.refreshThreshold);
-        if (j) {
-            L(`+++${n}__${r}`, s).then((async s => {
+        const p = lessThan(m, runIfFn(d, c) ?? e?.refreshThreshold);
+        if (p) {
+            coalesceAsync(`+++${a}__${r}`, s).then((async s => {
                 try {
-                    await p(e?.refreshAllStores ? i : i.slice(0, l + 1), r, s, f(s));
+                    await set(e?.refreshAllStores ? n : n.slice(0, h + 1), r, s, resolveTtl(s));
                     t.emit("refresh", {
                         key: r,
                         value: s
@@ -600,40 +1514,40 @@ var B = e => {
                 });
             }));
         }
-        if (!j && l > 0) {
-            await p(i.slice(0, l), r, c, f(c));
+        if (!p && h > 0) {
+            await set(n.slice(0, h), r, c, resolveTtl(c));
         }
-        return y ? m : c;
+        return f ? l : c;
     }));
-    const j = (e, r) => t.addListener(e, r);
-    const b = (e, r) => t.removeListener(e, r);
-    const v = async () => {
+    const on = (e, r) => t.addListener(e, r);
+    const off = (e, r) => t.removeListener(e, r);
+    const disconnect = async () => {
         try {
-            await Promise.all(i.map((async e => e.disconnect())));
+            await Promise.all(n.map((async e => e.disconnect())));
         } catch (e) {
             return Promise.reject(e);
         }
     };
-    const g = () => n;
+    const cacheId = () => a;
     return {
-        get: c,
-        mget: m,
-        ttl: l,
-        set: async (e, t, r) => p(i, e, t, r),
-        mset: async e => h(i, e),
-        del: d,
-        mdel: u,
-        clear: y,
-        wrap: f,
-        on: j,
-        off: b,
-        disconnect: v,
-        cacheId: g,
-        stores: i
+        get,
+        mget,
+        ttl,
+        set: async (e, t, r) => set(n, e, t, r),
+        mset: async e => mset(n, e),
+        del,
+        mdel,
+        clear,
+        wrap,
+        on,
+        off,
+        disconnect,
+        cacheId,
+        stores: n
     };
 };
 
-const N = e => ({
+const BuildCacherOptions = e => ({
     class: Cacher,
     stores: e?.stores,
     ttl: e?.ttl,
@@ -643,38 +1557,38 @@ const N = e => ({
     cacheId: e?.cacheId
 });
 
-class Cacher extends o {
+class Cacher extends n {
     async init() {
         const e = this.stores ? Array.isArray(this.stores) ? this.stores : [ this.stores ] : [];
         const t = await Promise.all(e.map((e => {
             switch (e.type) {
               case "file":
-                return n(e);
+                return c(e);
 
               case "redis":
-                return c(e);
+                return l(e);
 
               case "memcache":
-                return m(e);
+                return h(e);
 
               case "mongo":
-                return l(e);
+                return m(e);
 
               case "sqlite":
-                return p(e);
+                return u(e);
 
               case "postgres":
-                return h(e);
+                return d(e);
 
               case "mysql":
-                return d(e);
+                return f(e);
 
               default:
                 return undefined;
             }
         })));
         const r = t.filter((e => !!e));
-        this.cache = B({
+        this.cache = createCache({
             stores: r.length ? r : undefined,
             ttl: this.ttl,
             refreshThreshold: this.refreshThreshold,
@@ -721,16 +1635,16 @@ class Cacher extends o {
     }
 }
 
-e([ i(u.Alternatives(u.Array(u.Alternatives(y.Schema(), f.Schema(), j.Schema(), b.Schema(), v.Schema(), g.Schema(), k.Schema())), y.Schema(), f.Schema(), j.Schema(), b.Schema(), v.Schema(), g.Schema(), k.Schema()).optional()), t("design:type", Object) ], Cacher.prototype, "stores", void 0);
+e([ o(p.Alternatives(p.Array(p.Alternatives(y.Schema(), g.Schema(), b.Schema(), v.Schema(), _.Schema(), j.Schema(), w.Schema())), y.Schema(), g.Schema(), b.Schema(), v.Schema(), _.Schema(), j.Schema(), w.Schema()).optional()), t("design:type", Object) ], Cacher.prototype, "stores", void 0);
 
-e([ i(u.Number().positive().integer().optional()), t("design:type", Number) ], Cacher.prototype, "ttl", void 0);
+e([ o(p.Number().positive().integer().optional()), t("design:type", Number) ], Cacher.prototype, "ttl", void 0);
 
-e([ i(u.Number().positive().integer().optional()), t("design:type", Number) ], Cacher.prototype, "refreshThreshold", void 0);
+e([ o(p.Number().positive().integer().optional()), t("design:type", Number) ], Cacher.prototype, "refreshThreshold", void 0);
 
-e([ i(u.Boolean().optional()), t("design:type", Boolean) ], Cacher.prototype, "refreshAllStores", void 0);
+e([ o(p.Boolean().optional()), t("design:type", Boolean) ], Cacher.prototype, "refreshAllStores", void 0);
 
-e([ i(u.Boolean().optional()), t("design:type", Boolean) ], Cacher.prototype, "nonBlocking", void 0);
+e([ o(p.Boolean().optional()), t("design:type", Boolean) ], Cacher.prototype, "nonBlocking", void 0);
 
-e([ i(u.String().optional()), t("design:type", String) ], Cacher.prototype, "cacheId", void 0);
+e([ o(p.String().optional()), t("design:type", String) ], Cacher.prototype, "cacheId", void 0);
 
-export { N as BuildCacherOptions, Cacher };
+export { BuildCacherOptions, Cacher };