lakutata 2.0.80 → 2.0.82

package/src/components/cacher/Cacher.cjs

@@ -6,45 +6,47 @@ Object.defineProperty(exports, Symbol.toStringTag, {
 
 const e = require("../../../vendor/Package.1.cjs");
 
-const r = require("events");
+const t = require("events");
 
-const t = require("../../../vendor/Package.67.cjs");
+const r = require("../../../vendor/Package.66.cjs");
 
-const s = require("../../lib/core/Component.cjs");
+const s = require("../../../vendor/Package.67.cjs");
 
-const c = require("../../decorators/di/Configurable.cjs");
+const i = require("../../lib/core/Component.cjs");
 
-const i = require("../../lib/helpers/As.cjs");
+const n = require("../../decorators/di/Configurable.cjs");
 
-const a = require("./adapters/CreateFileCacheAdapter.cjs");
+const a = require("../../lib/helpers/As.cjs");
 
-const n = require("./adapters/CreateRedisCacheAdapter.cjs");
+const o = require("./adapters/CreateFileCacheAdapter.cjs");
 
-const o = require("./adapters/CreateMemcacheCacheAdapter.cjs");
+const c = require("./adapters/CreateRedisCacheAdapter.cjs");
 
-const l = require("./adapters/CreateMongoCacheAdapter.cjs");
+const l = require("./adapters/CreateMemcacheCacheAdapter.cjs");
+
+const h = require("./adapters/CreateMongoCacheAdapter.cjs");
 
 const u = require("./adapters/CreateSqliteCacheAdapter.cjs");
 
-const h = require("./adapters/CreatePostgresCacheAdapter.cjs");
+const d = require("./adapters/CreatePostgresCacheAdapter.cjs");
 
-const d = require("./adapters/CreateMysqlCacheAdapter.cjs");
+const f = require("./adapters/CreateMysqlCacheAdapter.cjs");
 
-const p = require("../../../vendor/Package.2.cjs");
+const m = require("../../../vendor/Package.2.cjs");
 
-const m = require("./options/FileCacheOptions.cjs");
+const y = require("./options/FileCacheOptions.cjs");
 
-const y = require("./options/RedisCacheOptions.cjs");
+const g = require("./options/RedisCacheOptions.cjs");
 
-const j = require("./options/MemcacheCacheOptions.cjs");
+const p = require("./options/MemcacheCacheOptions.cjs");
 
-const q = require("./options/MongoCacheOptions.cjs");
+const b = require("./options/MongoCacheOptions.cjs");
 
-const f = require("./options/SqliteCacheOptions.cjs");
+const _ = require("./options/SqliteCacheOptions.cjs");
 
-const b = require("./options/PostgresCacheOptions.cjs");
+const v = require("./options/PostgresCacheOptions.cjs");
 
-const C = require("./options/MysqlCacheOptions.cjs");
+const j = require("./options/MysqlCacheOptions.cjs");
 
 require("buffer");
 
@@ -140,10 +142,12 @@ require("os");
 
 require("path");
 
-require("stream");
-
 require("fs");
 
+require("../../../vendor/Package.10.cjs");
+
+require("stream");
+
 require("../../lib/ioc/Utils.cjs");
 
 require("../../lib/ioc/FunctionTokenizer.cjs");
@@ -186,15 +190,9 @@ require("../../lib/core/Provider.cjs");
 
 require("../../../vendor/Package.12.cjs");
 
-require("../../../vendor/Package.18.cjs");
-
-require("constants");
-
-require("../../../vendor/Package.15.cjs");
+require("fs/promises");
 
-require("assert");
-
-require("../../../vendor/Package.122.cjs");
+require("../../../vendor/Package.14.cjs");
 
 require("./lib/IsDriverPackageInstalled.cjs");
 
@@ -202,97 +200,967 @@ require("./exceptions/CacheDriverNotFoundException.cjs");
 
 require("../../lib/helpers/URLBuilder.cjs");
 
-const g = e => e && e.__esModule ? e : {
+const _interopDefault = e => e && e.__esModule ? e : {
     default: e
 };
 
-const v = g(r);
+const w = _interopDefault(t);
+
+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 q = 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 A = 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 C = 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 k = 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 a = 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);
+            a ^= n;
+            a = this._rotl32(a, 13);
+            a = this._imul(a, 5) + 3864292196;
+        }
+        const o = n * 4;
+        let c = 0;
+        switch (i & 3) {
+          case 3:
+            c ^= (t[o + 2] & 255) << 16;
+
+          case 2:
+            c ^= (t[o + 1] & 255) << 8;
+
+          case 1:
+            c ^= t[o] & 255;
+            c = this._imul(c, r);
+            c = this._rotl32(c, 15);
+            c = this._imul(c, s);
+            a ^= c;
+        }
+        a ^= i;
+        a ^= a >>> 16;
+        a = this._imul(a, 2246822507);
+        a ^= a >>> 13;
+        a = this._imul(a, 3266489909);
+        a ^= a >>> 16;
+        a = a >>> 0;
+        const l = a.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 O = 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 x = class extends r.Hookified {
+    _parse=JSON.parse;
+    _stringify=JSON.stringify;
+    _providers=new O;
+    _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 a = this._providers.get(r.algorithm);
+        if (!a) {
+            a = new q({
+                algorithm: this._defaultAlgorithm
+            });
+        }
+        let o = await a.toHash(n);
+        if (t?.maxLength && o.length > t?.maxLength) {
+            o = o.substring(0, t.maxLength);
+        }
+        const c = {
+            hash: o,
+            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 a = await this.toHash(e, {
+            algorithm: i,
+            maxLength: n
+        });
+        const o = Number.parseInt(a, 16);
+        const c = s - r + 1;
+        const l = r + o % 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 a = n.encode(i);
+        const o = this._providers.get(s);
+        if (!o) {
+            throw new Error(`Hash provider '${s}' not found`);
+        }
+        if (!o.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 = o.toHashSync(a);
+        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 a = this.toHashSync(e, {
+            algorithm: i,
+            maxLength: n
+        });
+        const o = Number.parseInt(a, 16);
+        const c = s - r + 1;
+        const l = r + o % 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 q({
+                algorithm: "SHA-256"
+            }));
+            this.providers.add(new q({
+                algorithm: "SHA-384"
+            }));
+            this.providers.add(new q({
+                algorithm: "SHA-512"
+            }));
+            this.providers.add(new S);
+            this.providers.add(new A);
+            this.providers.add(new C);
+            this.providers.add(new k);
+        }
+    }
+};
+
+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 a = i.toLowerCase();
+            switch (a) {
+              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 k = new Map;
+var P = new Map;
 
-function P(e) {
-    return k.has(e);
+function hasKey(e) {
+    return P.has(e);
 }
 
-function w(e) {
-    k.set(e, []);
+function addKey(e) {
+    P.set(e, []);
 }
 
-function O(e) {
-    k.delete(e);
+function removeKey(e) {
+    P.delete(e);
 }
 
-function _(e, r) {
-    const t = A(e);
-    t.push(r);
-    k.set(e, t);
+function addCallbackToKey(e, t) {
+    const r = getCallbacksByKey(e);
+    r.push(t);
+    P.set(e, r);
 }
 
-function A(e) {
-    return k.get(e) ?? [];
+function getCallbacksByKey(e) {
+    return P.get(e) ?? [];
 }
 
-async function S(e) {
-    return new Promise(((r, t) => {
+async function enqueue(e) {
+    return new Promise(((t, r) => {
         const s = {
-            resolve: r,
-            reject: t
+            resolve: t,
+            reject: r
         };
-        _(e, s);
+        addCallbackToKey(e, s);
     }));
 }
 
-function M(e) {
-    const r = A(e);
-    O(e);
-    return r;
+function dequeue(e) {
+    const t = getCallbacksByKey(e);
+    removeKey(e);
+    return t;
 }
 
-function x(e) {
-    const {key: r, error: t, result: s} = e;
-    for (const e of M(r)) {
-        if (t) {
-            e.reject(t);
+function coalesce(e) {
+    const {key: t, error: r, result: s} = e;
+    for (const e of dequeue(t)) {
+        if (r) {
+            e.reject(r);
         } else {
             e.resolve(s);
         }
     }
 }
 
-async function I(e, r) {
-    if (!P(e)) {
-        w(e);
+async function coalesceAsync(e, t) {
+    if (!hasKey(e)) {
+        addKey(e);
         try {
-            const t = await Promise.resolve(r());
-            x({
+            const r = await Promise.resolve(t());
+            coalesce({
                 key: e,
-                result: t
+                result: r
             });
-            return t;
-        } catch (r) {
-            x({
+            return r;
+        } catch (t) {
+            coalesce({
                 key: e,
-                error: r
+                error: t
             });
-            throw r;
+            throw t;
         }
     }
-    return S(e);
+    return enqueue(e);
+}
+
+var z = (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;
+})(z || {});
+
+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 x;
+    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 x;
+    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 a = t?.hashLength ?? 16;
+    if (r >= s) {
+        throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
+    }
+    const o = n(e);
+    const c = new x;
+    return c.toNumber(o, {
+        algorithm: i,
+        min: r,
+        max: s,
+        hashLength: a
+    });
+}
+
+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 a = t?.hashLength ?? 16;
+    if (r >= s) {
+        throw new Error(`Invalid range: min (${r}) must be less than max (${s})`);
+    }
+    const o = n(e);
+    const c = new x;
+    return c.toNumberSync(o, {
+        algorithm: i,
+        min: r,
+        max: s,
+        hashLength: a
+    });
 }
 
-function T(e) {
+function isKeyvInstance(e) {
+    if (e === null || e === void 0) {
+        return false;
+    }
+    if (e instanceof s.Keyv) {
+        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 D(e, ...r) {
-    return typeof e === "function" ? e(...r) : e;
+function lessThan(e, t) {
+    return typeof e === "number" && typeof t === "number" ? e < t : false;
 }
 
-function L(e, r) {
-    return typeof e === "number" && typeof r === "number" ? e < r : false;
+function wrapSync(e, t) {
+    const {ttl: r, keyPrefix: s, cache: i, serialize: n} = t;
+    return (...a) => {
+        let o = createWrapKey(e, a, {
+            keyPrefix: s,
+            serialize: n
+        });
+        if (t.createKey) {
+            o = t.createKey(e, a, t);
+        }
+        let c = i.get(o);
+        if (c === void 0) {
+            try {
+                c = e(...a);
+                i.set(o, c, r);
+            } catch (e) {
+                i.emit("error", e);
+                if (t.cacheErrors) {
+                    i.set(o, e, r);
+                }
+            }
+        }
+        return c;
+    };
 }
 
-var B = class {
+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;
+}
+
+var sleep = async e => new Promise((t => setTimeout(t, e)));
+
+var H = 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;
+}
+
+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 M = class {
     opts;
     namespace;
     _cache;
@@ -300,14 +1168,14 @@ var B = class {
         this._cache = e;
     }
     async get(e) {
-        const r = await this._cache.get(e);
-        if (r !== void 0 && r !== null) {
-            return r;
+        const t = await this._cache.get(e);
+        if (t !== void 0 && t !== null) {
+            return t;
         }
         return void 0;
     }
-    async set(e, r, t) {
-        await this._cache.set(e, r, t);
+    async set(e, t, r) {
+        await this._cache.set(e, t, r);
         return true;
     }
     async delete(e) {
@@ -318,8 +1186,8 @@ var B = class {
         return this._cache.reset?.();
     }
     async has(e) {
-        const r = await this._cache.get(e);
-        if (r) {
+        const t = await this._cache.get(e);
+        if (t) {
             return true;
         }
         return false;
@@ -331,8 +1199,8 @@ var B = class {
         await this._cache.mdel(...e);
         return true;
     }
-    on(e, r) {
-        this._cache.on?.(e, r);
+    on(e, t) {
+        this._cache.on?.(e, t);
         return this;
     }
     async disconnect() {
@@ -340,312 +1208,358 @@ var B = class {
     }
 };
 
-var E = e => {
-    const r = new v.default;
-    const s = new t.Keyv;
-    s.serialize = void 0;
-    s.deserialize = void 0;
-    const c = e?.stores?.length ? e.stores : [ s ];
-    const i = e?.nonBlocking ?? false;
+var _storeLabel = e => e === 0 ? "primary" : `secondary:${e - 1}`;
+
+var createCache = e => {
+    const t = new w.default;
+    const r = new s.Keyv;
+    r.serialize = void 0;
+    r.deserialize = void 0;
+    const i = e?.stores?.length ? e.stores : [ r ];
+    const n = e?.nonBlocking ?? false;
     const a = e?.cacheId ?? Math.random().toString(36).slice(2);
-    const n = async e => {
-        let t;
-        if (i) {
+    const get = async e => {
+        let r;
+        if (n) {
             try {
-                t = await Promise.race(c.map((async r => r.get(e))));
-                if (t === void 0) {
+                r = await Promise.race(i.map((async t => t.get(e))));
+                if (r === void 0) {
                     return void 0;
                 }
-            } catch (t) {
-                r.emit("get", {
+            } catch (r) {
+                t.emit("get", {
                     key: e,
-                    error: t
+                    error: r
                 });
             }
         } else {
-            for (const s of c) {
+            for (let s = 0; s < i.length; s++) {
+                const n = i[s];
                 try {
-                    const c = await s.get(e);
-                    if (c !== void 0) {
-                        t = c;
-                        r.emit("get", {
+                    const i = await n.get(e);
+                    if (i !== void 0) {
+                        r = i;
+                        t.emit("get", {
                             key: e,
-                            value: t
+                            value: r,
+                            store: _storeLabel(s)
                         });
                         break;
                     }
-                } catch (t) {
-                    r.emit("get", {
+                } catch (r) {
+                    t.emit("get", {
                         key: e,
-                        error: t
+                        error: r,
+                        store: _storeLabel(s)
                     });
                 }
             }
         }
-        return t;
+        return r;
     };
-    const o = async e => {
-        const r = [];
-        for (const t of e) {
-            const e = await n(t);
-            r.push(e);
+    const mget = async e => {
+        let r = e.map((() => void 0));
+        if (n) {
+            try {
+                r = await Promise.race(i.map((async t => t.getMany(e))));
+            } catch (r) {
+                t.emit("mget", {
+                    keys: e,
+                    error: r
+                });
+            }
+        } else {
+            for (const s of i) {
+                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
+                    });
+                }
+            }
         }
+        t.emit("mget", {
+            keys: e,
+            values: r
+        });
         return r;
     };
-    const l = async e => {
-        let t;
-        if (i) {
+    const ttl = async e => {
+        let r;
+        if (n) {
             try {
-                t = await Promise.race(c.map((async r => r.get(e, {
+                r = await Promise.race(i.map((async t => t.get(e, {
                     raw: true
                 }))));
-                if (t === void 0) {
+                if (r === void 0) {
                     return void 0;
                 }
-            } catch (t) {
-                r.emit("ttl", {
+            } catch (r) {
+                t.emit("ttl", {
                     key: e,
-                    error: t
+                    error: r
                 });
             }
         } else {
-            for (const s of c) {
+            for (const s of i) {
                 try {
-                    const c = await s.get(e, {
+                    const i = await s.get(e, {
                         raw: true
                     });
-                    if (c !== void 0) {
-                        t = c;
-                        r.emit("ttl", {
+                    if (i !== void 0) {
+                        r = i;
+                        t.emit("ttl", {
                             key: e,
-                            value: t
+                            value: r
                         });
                         break;
                     }
-                } catch (t) {
-                    r.emit("ttl", {
+                } catch (r) {
+                    t.emit("ttl", {
                         key: e,
-                        error: t
+                        error: r
                     });
                 }
             }
         }
-        if (t?.expires) {
-            return t.expires;
+        if (r?.expires) {
+            return r.expires;
         }
         return void 0;
     };
-    const u = async (t, s, c, a) => {
+    const set = async (r, s, i, a) => {
         try {
-            if (i) {
-                Promise.all(t.map((async r => r.set(s, c, a ?? e?.ttl))));
-                r.emit("set", {
+            const o = r.map((async (r, n) => {
+                await r.set(s, i, a ?? e?.ttl);
+                t.emit("set", {
+                    key: s,
+                    value: i,
+                    store: _storeLabel(n)
+                });
+            }));
+            if (n) {
+                Promise.all(o);
+                t.emit("set", {
                     key: s,
-                    value: c
+                    value: i
                 });
-                return c;
+                return i;
             }
-            await Promise.all(t.map((async r => r.set(s, c, a ?? e?.ttl))));
-            r.emit("set", {
+            await Promise.all(o);
+            t.emit("set", {
                 key: s,
-                value: c
+                value: i
             });
-            return c;
+            return i;
         } catch (e) {
-            r.emit("set", {
+            t.emit("set", {
                 key: s,
-                value: c,
+                value: i,
                 error: e
             });
             return Promise.reject(e);
         }
     };
-    const h = async (e, t) => {
-        const s = t.map((({key: e, value: r, ttl: t}) => ({
-            key: e,
+    const mset = async (r, s) => {
+        const i = s.map((({key: t, value: r, ttl: s}) => ({
+            key: t,
             value: r,
-            ttl: t
+            ttl: s ?? e?.ttl
         })));
         try {
-            const s = [];
-            for (const r of t) {
-                s.push(...e.map((async e => e.set(r.key, r.value, r.ttl))));
-            }
-            if (i) {
-                Promise.all(s);
-                r.emit("mset", {
-                    list: t
+            const e = r.map((async e => e.setMany(i)));
+            if (n) {
+                Promise.all(e);
+                t.emit("mset", {
+                    list: i
                 });
-                return t;
+                return i;
             }
-            await Promise.all(s);
-            r.emit("mset", {
-                list: t
+            await Promise.all(e);
+            t.emit("mset", {
+                list: i
             });
-            return t;
+            return i;
         } catch (e) {
-            r.emit("mset", {
-                list: t,
+            t.emit("mset", {
+                list: i,
                 error: e
             });
             return Promise.reject(e);
         }
     };
-    const d = async e => {
+    const del = async e => {
         try {
-            if (i) {
-                Promise.all(c.map((async r => r.delete(e))));
-                r.emit("del", {
+            if (n) {
+                Promise.all(i.map((async t => t.delete(e))));
+                t.emit("del", {
                     key: e
                 });
                 return true;
             }
-            await Promise.all(c.map((async r => r.delete(e))));
-            r.emit("del", {
+            await Promise.all(i.map((async t => t.delete(e))));
+            t.emit("del", {
                 key: e
             });
             return true;
-        } catch (t) {
-            r.emit("del", {
+        } catch (r) {
+            t.emit("del", {
                 key: e,
-                error: t
+                error: r
             });
-            return Promise.reject(t);
+            return Promise.reject(r);
         }
     };
-    const p = async e => {
+    const mdel = async e => {
         try {
-            const t = [];
-            for (const r of e) {
-                t.push(...c.map((async e => e.delete(r))));
+            const r = [];
+            for (const t of e) {
+                r.push(...i.map((async e => e.delete(t))));
             }
-            if (i) {
-                Promise.all(t);
-                r.emit("mdel", {
+            if (n) {
+                Promise.all(r);
+                t.emit("mdel", {
                     keys: e
                 });
                 return true;
             }
-            await Promise.all(t);
-            r.emit("mdel", {
+            await Promise.all(r);
+            t.emit("mdel", {
                 keys: e
             });
             return true;
-        } catch (t) {
-            r.emit("mdel", {
+        } catch (r) {
+            t.emit("mdel", {
                 keys: e,
-                error: t
+                error: r
             });
-            return Promise.reject(t);
+            return Promise.reject(r);
         }
     };
-    const m = async () => {
+    const clear = async () => {
         try {
-            if (i) {
-                Promise.all(c.map((async e => e.clear())));
-                r.emit("clear");
+            if (n) {
+                Promise.all(i.map((async e => e.clear())));
+                t.emit("clear");
                 return true;
             }
-            await Promise.all(c.map((async e => e.clear())));
-            r.emit("clear");
+            await Promise.all(i.map((async e => e.clear())));
+            t.emit("clear");
             return true;
         } catch (e) {
-            r.emit("clear", e);
+            t.emit("clear", e);
             return Promise.reject(e);
         }
     };
-    const y = async (t, s, i, n) => I(`${a}::${t}`, (async () => {
-        let o;
+    const wrap = async (r, s, n, o) => coalesceAsync(`${a}::${r}`, (async () => {
+        let c;
         let l;
         let h = 0;
-        let d;
-        const {ttl: p, refreshThreshold: m, raw: y} = T(i) ? i : {
-            ttl: i,
-            refreshThreshold: n
+        let u;
+        const {ttl: d, refreshThreshold: f, raw: m} = isObject(n) ? n : {
+            ttl: n,
+            refreshThreshold: o
         };
-        const j = r => D(p, r) ?? e?.ttl;
-        for (;h < c.length; h++) {
+        const resolveTtl = t => runIfFn(d, t) ?? e?.ttl;
+        for (;h < i.length; h++) {
             try {
-                const e = await c[h].get(t, {
+                const e = await i[h].get(r, {
                     raw: true
                 });
                 if (e !== void 0) {
-                    o = e.value;
+                    c = e.value;
                     l = e;
                     if (typeof e.expires === "number") {
-                        d = Math.max(0, e.expires - Date.now());
+                        u = Math.max(0, e.expires - Date.now());
                     }
                     break;
                 }
             } catch {}
         }
-        if (o === void 0) {
+        if (c === void 0) {
             const e = await s();
-            const r = j(e);
-            await u(c, t, e, r);
-            return y ? {
+            const t = resolveTtl(e);
+            await set(i, r, e, t);
+            return m ? {
                 value: e,
-                expires: Date.now() + r
+                expires: Date.now() + t
             } : e;
         }
-        const q = L(d, D(m, o) ?? e?.refreshThreshold);
-        if (q) {
-            I(`+++${a}__${t}`, s).then((async s => {
+        const y = lessThan(u, runIfFn(f, c) ?? e?.refreshThreshold);
+        if (y) {
+            coalesceAsync(`+++${a}__${r}`, s).then((async s => {
                 try {
-                    await u(e?.refreshAllStores ? c : c.slice(0, h + 1), t, s, j(s));
-                    r.emit("refresh", {
-                        key: t,
+                    await set(e?.refreshAllStores ? i : i.slice(0, h + 1), r, s, resolveTtl(s));
+                    t.emit("refresh", {
+                        key: r,
                         value: s
                     });
                 } catch (e) {
-                    r.emit("refresh", {
-                        key: t,
-                        value: o,
+                    t.emit("refresh", {
+                        key: r,
+                        value: c,
                         error: e
                     });
                 }
             })).catch((e => {
-                r.emit("refresh", {
-                    key: t,
-                    value: o,
+                t.emit("refresh", {
+                    key: r,
+                    value: c,
                     error: e
                 });
             }));
         }
-        if (!q && h > 0) {
-            await u(c.slice(0, h), t, o, j(o));
+        if (!y && h > 0) {
+            await set(i.slice(0, h), r, c, resolveTtl(c));
         }
-        return y ? l : o;
+        return m ? l : c;
     }));
-    const j = (e, t) => r.addListener(e, t);
-    const q = (e, t) => r.removeListener(e, t);
-    const f = async () => {
+    const on = (e, r) => t.addListener(e, r);
+    const off = (e, r) => t.removeListener(e, r);
+    const disconnect = async () => {
         try {
-            await Promise.all(c.map((async e => e.disconnect())));
+            await Promise.all(i.map((async e => e.disconnect())));
         } catch (e) {
             return Promise.reject(e);
         }
     };
-    const b = () => a;
+    const cacheId = () => a;
     return {
-        get: n,
-        mget: o,
-        ttl: l,
-        set: async (e, r, t) => u(c, e, r, t),
-        mset: async e => h(c, e),
-        del: d,
-        mdel: p,
-        clear: m,
-        wrap: y,
-        on: j,
-        off: q,
-        disconnect: f,
-        cacheId: b,
-        stores: c
+        get,
+        mget,
+        ttl,
+        set: async (e, t, r) => set(i, e, t, r),
+        mset: async e => mset(i, e),
+        del,
+        mdel,
+        clear,
+        wrap,
+        on,
+        off,
+        disconnect,
+        cacheId,
+        stores: i
     };
 };
 
-const R = e => ({
+const BuildCacherOptions = e => ({
     class: Cacher,
     stores: e?.stores,
     ttl: e?.ttl,
@@ -655,39 +1569,39 @@ const R = e => ({
     cacheId: e?.cacheId
 });
 
-class Cacher extends s.Component {
+class Cacher extends i.Component {
     async init() {
         const e = this.stores ? Array.isArray(this.stores) ? this.stores : [ this.stores ] : [];
-        const r = await Promise.all(e.map((e => {
+        const t = await Promise.all(e.map((e => {
             switch (e.type) {
               case "file":
-                return a.CreateFileCacheAdapter(e);
+                return o.CreateFileCacheAdapter(e);
 
               case "redis":
-                return n.CreateRedisCacheAdapter(e);
+                return c.CreateRedisCacheAdapter(e);
 
               case "memcache":
-                return o.CreateMemcacheCacheAdapter(e);
+                return l.CreateMemcacheCacheAdapter(e);
 
               case "mongo":
-                return l.CreateMongoCacheAdapter(e);
+                return h.CreateMongoCacheAdapter(e);
 
               case "sqlite":
                 return u.CreateSqliteCacheAdapter(e);
 
               case "postgres":
-                return h.CreatePostgresCacheAdapter(e);
+                return d.CreatePostgresCacheAdapter(e);
 
               case "mysql":
-                return d.CreateMysqlCacheAdapter(e);
+                return f.CreateMysqlCacheAdapter(e);
 
               default:
                 return undefined;
             }
         })));
-        const t = r.filter((e => !!e));
-        this.cache = E({
-            stores: t.length ? t : undefined,
+        const r = t.filter((e => !!e));
+        this.cache = createCache({
+            stores: r.length ? r : undefined,
             ttl: this.ttl,
             refreshThreshold: this.refreshThreshold,
             refreshAllStores: this.refreshAllStores,
@@ -702,22 +1616,22 @@ class Cacher extends s.Component {
     async destroy() {
         await this.cache.disconnect();
     }
-    async set(e, r, t) {
-        return await this.cache.set(e, r, t);
+    async set(e, t, r) {
+        return await this.cache.set(e, t, r);
     }
     async multipleSet(e) {
         return await this.cache.mset(e);
     }
     async get(e) {
-        return i.As(await this.cache.get(e));
+        return a.As(await this.cache.get(e));
     }
     async multipleGet(e) {
         return await this.cache.mget(e);
     }
     async getTTL(e) {
-        const r = await this.cache.ttl(e);
-        if (r === undefined) return -1;
-        return r;
+        const t = await this.cache.ttl(e);
+        if (t === undefined) return -1;
+        return t;
     }
     async del(e) {
         return await this.cache.del(e);
@@ -728,23 +1642,23 @@ class Cacher extends s.Component {
     async clear() {
         return await this.cache.clear();
     }
-    on(e, r) {
-        return super.on(e, r);
+    on(e, t) {
+        return super.on(e, t);
     }
 }
 
-e.__decorate([ c.Configurable(p.DTO.Alternatives(p.DTO.Array(p.DTO.Alternatives(m.FileCacheOptions.Schema(), y.RedisCacheOptions.Schema(), j.MemcacheCacheOptions.Schema(), q.MongoCacheOptions.Schema(), f.SqliteCacheOptions.Schema(), b.PostgresCacheOptions.Schema(), C.MysqlCacheOptions.Schema())), m.FileCacheOptions.Schema(), y.RedisCacheOptions.Schema(), j.MemcacheCacheOptions.Schema(), q.MongoCacheOptions.Schema(), f.SqliteCacheOptions.Schema(), b.PostgresCacheOptions.Schema(), C.MysqlCacheOptions.Schema()).optional()), e.__metadata("design:type", Object) ], Cacher.prototype, "stores", void 0);
+e.__decorate([ n.Configurable(m.DTO.Alternatives(m.DTO.Array(m.DTO.Alternatives(y.FileCacheOptions.Schema(), g.RedisCacheOptions.Schema(), p.MemcacheCacheOptions.Schema(), b.MongoCacheOptions.Schema(), _.SqliteCacheOptions.Schema(), v.PostgresCacheOptions.Schema(), j.MysqlCacheOptions.Schema())), y.FileCacheOptions.Schema(), g.RedisCacheOptions.Schema(), p.MemcacheCacheOptions.Schema(), b.MongoCacheOptions.Schema(), _.SqliteCacheOptions.Schema(), v.PostgresCacheOptions.Schema(), j.MysqlCacheOptions.Schema()).optional()), e.__metadata("design:type", Object) ], Cacher.prototype, "stores", void 0);
 
-e.__decorate([ c.Configurable(p.DTO.Number().positive().integer().optional()), e.__metadata("design:type", Number) ], Cacher.prototype, "ttl", void 0);
+e.__decorate([ n.Configurable(m.DTO.Number().positive().integer().optional()), e.__metadata("design:type", Number) ], Cacher.prototype, "ttl", void 0);
 
-e.__decorate([ c.Configurable(p.DTO.Number().positive().integer().optional()), e.__metadata("design:type", Number) ], Cacher.prototype, "refreshThreshold", void 0);
+e.__decorate([ n.Configurable(m.DTO.Number().positive().integer().optional()), e.__metadata("design:type", Number) ], Cacher.prototype, "refreshThreshold", void 0);
 
-e.__decorate([ c.Configurable(p.DTO.Boolean().optional()), e.__metadata("design:type", Boolean) ], Cacher.prototype, "refreshAllStores", void 0);
+e.__decorate([ n.Configurable(m.DTO.Boolean().optional()), e.__metadata("design:type", Boolean) ], Cacher.prototype, "refreshAllStores", void 0);
 
-e.__decorate([ c.Configurable(p.DTO.Boolean().optional()), e.__metadata("design:type", Boolean) ], Cacher.prototype, "nonBlocking", void 0);
+e.__decorate([ n.Configurable(m.DTO.Boolean().optional()), e.__metadata("design:type", Boolean) ], Cacher.prototype, "nonBlocking", void 0);
 
-e.__decorate([ c.Configurable(p.DTO.String().optional()), e.__metadata("design:type", String) ], Cacher.prototype, "cacheId", void 0);
+e.__decorate([ n.Configurable(m.DTO.String().optional()), e.__metadata("design:type", String) ], Cacher.prototype, "cacheId", void 0);
 
-exports.BuildCacherOptions = R;
+exports.BuildCacherOptions = BuildCacherOptions;
 
 exports.Cacher = Cacher;