lakutata 2.0.34 → 2.0.35

package/vendor/Package.19.mjs

@@ -0,0 +1,4442 @@
+import { _ as e, a as t } from "./Package.1.mjs";
+
+import r from "events";
+
+import n, { Buffer as i } from "buffer";
+
+import { c as s, g as o } from "./Package.5.mjs";
+
+import { r as c } from "./Package.12.mjs";
+
+import "./Package.8.mjs";
+
+import "./Package.18.mjs";
+
+import a from "constants";
+
+import f from "stream";
+
+import "./Package.10.mjs";
+
+import "./Package.16.mjs";
+
+import u from "fs";
+
+import l from "util";
+
+import h from "assert";
+
+import p from "os";
+
+import y from "path";
+
+import "./Package.13.mjs";
+
+import { CacherOptions as d } from "../src/components/cacher/options/CacherOptions.mjs";
+
+import { Component as m } from "../src/lib/core/Component.mjs";
+
+import { Configurable as v } from "../src/decorators/di/Configurable.mjs";
+
+import { URLBuilder as w } from "../src/lib/helpers/URLBuilder.mjs";
+
+import { As as S } from "../src/lib/helpers/As.mjs";
+
+
+// -- Shims --
+import cjsUrl from 'node:url';
+import cjsPath from 'node:path';
+import cjsModule from 'node:module';
+const __filename = cjsUrl.fileURLToPath(import.meta.url);
+const __dirname = cjsPath.dirname(__filename);
+const require = cjsModule.createRequire(import.meta.url);
+var g = e => {
+    if (e === void 0 || e === null) {
+        return "null";
+    }
+    if (typeof e === "string") {
+        return JSON.stringify(e.startsWith(":") ? ":" + e : e);
+    }
+    if (i.isBuffer(e)) {
+        return JSON.stringify(":base64:" + e.toString("base64"));
+    }
+    if (e?.toJSON) {
+        e = e.toJSON();
+    }
+    if (typeof e === "object") {
+        let t = "";
+        const r = Array.isArray(e);
+        t = r ? "[" : "{";
+        let n = true;
+        for (const i in e) {
+            const s = typeof e[i] === "function" || !r && e[i] === void 0;
+            if (!Object.hasOwn(e, i) || s) {
+                continue;
+            }
+            if (!n) {
+                t += ",";
+            }
+            n = false;
+            if (r) {
+                t += g(e[i]);
+            } else if (e[i] !== void 0) {
+                t += g(i) + ":" + g(e[i]);
+            }
+        }
+        t += r ? "]" : "}";
+        return t;
+    }
+    return JSON.stringify(e);
+};
+
+var k = e => JSON.parse(e, ((e, t) => {
+    if (typeof t === "string") {
+        if (t.startsWith(":base64:")) {
+            return i.from(t.slice(8), "base64");
+        }
+        return t.startsWith(":") ? t.slice(1) : t;
+    }
+    return t;
+}));
+
+var E = class {
+    _eventListeners;
+    _maxListeners;
+    constructor() {
+        this._eventListeners = new Map;
+        this._maxListeners = 100;
+    }
+    maxListeners() {
+        return this._maxListeners;
+    }
+    addListener(e, t) {
+        this.on(e, t);
+    }
+    on(e, t) {
+        if (!this._eventListeners.has(e)) {
+            this._eventListeners.set(e, []);
+        }
+        const r = this._eventListeners.get(e);
+        if (r) {
+            if (r.length >= this._maxListeners) {
+                console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${r.length + 1} ${e} listeners added. Use setMaxListeners() to increase limit.`);
+            }
+            r.push(t);
+        }
+        return this;
+    }
+    removeListener(e, t) {
+        this.off(e, t);
+    }
+    off(e, t) {
+        const r = this._eventListeners.get(e) ?? [];
+        const n = r.indexOf(t);
+        if (n !== -1) {
+            r.splice(n, 1);
+        }
+        if (r.length === 0) {
+            this._eventListeners.delete(e);
+        }
+    }
+    once(e, t) {
+        const r = (...n) => {
+            t(...n);
+            this.off(e, r);
+        };
+        this.on(e, r);
+    }
+    emit(e, ...t) {
+        const r = this._eventListeners.get(e);
+        if (r && r.length > 0) {
+            for (const e of r) {
+                e(...t);
+            }
+        }
+    }
+    listeners(e) {
+        return this._eventListeners.get(e) ?? [];
+    }
+    removeAllListeners(e) {
+        if (e) {
+            this._eventListeners.delete(e);
+        } else {
+            this._eventListeners.clear();
+        }
+    }
+    setMaxListeners(e) {
+        this._maxListeners = e;
+    }
+};
+
+var _ = E;
+
+var b = class extends _ {
+    _hookHandlers;
+    constructor() {
+        super();
+        this._hookHandlers = new Map;
+    }
+    addHandler(e, t) {
+        const r = this._hookHandlers.get(e);
+        if (r) {
+            r.push(t);
+        } else {
+            this._hookHandlers.set(e, [ t ]);
+        }
+    }
+    removeHandler(e, t) {
+        const r = this._hookHandlers.get(e);
+        if (r) {
+            const e = r.indexOf(t);
+            if (e !== -1) {
+                r.splice(e, 1);
+            }
+        }
+    }
+    trigger(e, t) {
+        const r = this._hookHandlers.get(e);
+        if (r) {
+            for (const n of r) {
+                try {
+                    n(t);
+                } catch (t) {
+                    this.emit("error", new Error(`Error in hook handler for event "${e}": ${t.message}`));
+                }
+            }
+        }
+    }
+    get handlers() {
+        return new Map(this._hookHandlers);
+    }
+};
+
+var x = b;
+
+var P = class extends _ {
+    enabled=true;
+    hits=0;
+    misses=0;
+    sets=0;
+    deletes=0;
+    errors=0;
+    constructor(e) {
+        super();
+        if (e !== void 0) {
+            this.enabled = e;
+        }
+        this.reset();
+    }
+    hit() {
+        if (this.enabled) {
+            this.hits++;
+        }
+    }
+    miss() {
+        if (this.enabled) {
+            this.misses++;
+        }
+    }
+    set() {
+        if (this.enabled) {
+            this.sets++;
+        }
+    }
+    delete() {
+        if (this.enabled) {
+            this.deletes++;
+        }
+    }
+    reset() {
+        this.hits = 0;
+        this.misses = 0;
+        this.sets = 0;
+        this.deletes = 0;
+        this.errors = 0;
+    }
+};
+
+var O = P;
+
+var D = (e => {
+    e["PRE_SET"] = "preSet";
+    e["POST_SET"] = "postSet";
+    e["PRE_GET"] = "preGet";
+    e["POST_GET"] = "postGet";
+    e["PRE_GET_MANY"] = "preGetMany";
+    e["POST_GET_MANY"] = "postGetMany";
+    e["PRE_DELETE"] = "preDelete";
+    e["POST_DELETE"] = "postDelete";
+    return e;
+})(D || {});
+
+var j = [ "sqlite", "postgres", "mysql", "mongo", "redis", "valkey", "etcd" ];
+
+var M = class extends _ {
+    opts;
+    iterator;
+    hooks=new x;
+    stats=new O(false);
+    _ttl;
+    _namespace;
+    _store=new Map;
+    _serialize=g;
+    _deserialize=k;
+    _compression;
+    _useKeyPrefix=true;
+    constructor(e, t) {
+        super();
+        t ??= {};
+        e ??= {};
+        this.opts = {
+            namespace: "keyv",
+            serialize: g,
+            deserialize: k,
+            emitErrors: true,
+            store: new Map,
+            ...t
+        };
+        if (e && e.get) {
+            this.opts.store = e;
+        } else {
+            this.opts = {
+                ...this.opts,
+                ...e
+            };
+        }
+        this._store = this.opts.store ?? new Map;
+        this._compression = this.opts.compression;
+        this._serialize = this.opts.serialize;
+        this._deserialize = this.opts.deserialize;
+        if (this.opts.namespace) {
+            this._namespace = this.opts.namespace;
+        }
+        if (this._store) {
+            if (!this._isValidStorageAdapter(this._store)) {
+                throw new Error("Invalid storage adapter");
+            }
+            if (typeof this._store.on === "function") {
+                this._store.on("error", (e => this.emit("error", e)));
+            }
+            this._store.namespace = this._namespace;
+            if (typeof this._store[Symbol.iterator] === "function" && this._store instanceof Map) {
+                this.iterator = this.generateIterator(this._store);
+            } else if ("iterator" in this._store && this._store.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(this._store.iterator.bind(this._store));
+            }
+        }
+        if (this.opts.stats) {
+            this.stats.enabled = this.opts.stats;
+        }
+        if (this.opts.ttl) {
+            this._ttl = this.opts.ttl;
+        }
+        if (this.opts.useKeyPrefix !== void 0) {
+            this._useKeyPrefix = this.opts.useKeyPrefix;
+        }
+    }
+    get store() {
+        return this._store;
+    }
+    set store(e) {
+        if (this._isValidStorageAdapter(e)) {
+            this._store = e;
+            this.opts.store = e;
+            if (typeof e.on === "function") {
+                e.on("error", (e => this.emit("error", e)));
+            }
+            if (this._namespace) {
+                this._store.namespace = this._namespace;
+            }
+            if (typeof e[Symbol.iterator] === "function" && e instanceof Map) {
+                this.iterator = this.generateIterator(e);
+            } else if ("iterator" in e && e.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(e.iterator.bind(e));
+            }
+        } else {
+            throw new Error("Invalid storage adapter");
+        }
+    }
+    get compression() {
+        return this._compression;
+    }
+    set compression(e) {
+        this._compression = e;
+    }
+    get namespace() {
+        return this._namespace;
+    }
+    set namespace(e) {
+        this._namespace = e;
+        this.opts.namespace = e;
+        this._store.namespace = e;
+        if (this.opts.store) {
+            this.opts.store.namespace = e;
+        }
+    }
+    get ttl() {
+        return this._ttl;
+    }
+    set ttl(e) {
+        this.opts.ttl = e;
+        this._ttl = e;
+    }
+    get serialize() {
+        return this._serialize;
+    }
+    set serialize(e) {
+        this.opts.serialize = e;
+        this._serialize = e;
+    }
+    get deserialize() {
+        return this._deserialize;
+    }
+    set deserialize(e) {
+        this.opts.deserialize = e;
+        this._deserialize = e;
+    }
+    get useKeyPrefix() {
+        return this._useKeyPrefix;
+    }
+    set useKeyPrefix(e) {
+        this._useKeyPrefix = e;
+        this.opts.useKeyPrefix = e;
+    }
+    generateIterator(e) {
+        const t = async function*() {
+            for await (const [t, r] of typeof e === "function" ? e(this._store.namespace) : e) {
+                const e = await this.deserializeData(r);
+                if (this._useKeyPrefix && this._store.namespace && !t.includes(this._store.namespace)) {
+                    continue;
+                }
+                if (typeof e.expires === "number" && Date.now() > e.expires) {
+                    this.delete(t);
+                    continue;
+                }
+                yield [ this._getKeyUnprefix(t), e.value ];
+            }
+        };
+        return t.bind(this);
+    }
+    _checkIterableAdapter() {
+        return j.includes(this._store.opts.dialect) || j.some((e => this._store.opts.url.includes(e)));
+    }
+    _getKeyPrefix(e) {
+        if (!this._useKeyPrefix) {
+            return e;
+        }
+        if (!this._namespace) {
+            return e;
+        }
+        return `${this._namespace}:${e}`;
+    }
+    _getKeyPrefixArray(e) {
+        if (!this._useKeyPrefix) {
+            return e;
+        }
+        if (!this._namespace) {
+            return e;
+        }
+        return e.map((e => `${this._namespace}:${e}`));
+    }
+    _getKeyUnprefix(e) {
+        if (!this._useKeyPrefix) {
+            return e;
+        }
+        return e.split(":").splice(1).join(":");
+    }
+    _isValidStorageAdapter(e) {
+        return e instanceof Map || typeof e.get === "function" && typeof e.set === "function" && typeof e.delete === "function" && typeof e.clear === "function";
+    }
+    async get(e, t) {
+        const {store: r} = this.opts;
+        const n = Array.isArray(e);
+        const i = n ? this._getKeyPrefixArray(e) : this._getKeyPrefix(e);
+        const s = e => typeof e.expires === "number" && Date.now() > e.expires;
+        if (n) {
+            if (t?.raw === true) {
+                return this.getMany(e, {
+                    raw: true
+                });
+            }
+            return this.getMany(e, {
+                raw: false
+            });
+        }
+        this.hooks.trigger("preGet", {
+            key: i
+        });
+        const o = await r.get(i);
+        const c = typeof o === "string" || this.opts.compression ? await this.deserializeData(o) : o;
+        if (c === void 0 || c === null) {
+            this.stats.miss();
+            return void 0;
+        }
+        if (s(c)) {
+            await this.delete(e);
+            this.stats.miss();
+            return void 0;
+        }
+        this.hooks.trigger("postGet", {
+            key: i,
+            value: c
+        });
+        this.stats.hit();
+        return t?.raw ? c : c.value;
+    }
+    async getMany(e, t) {
+        const {store: r} = this.opts;
+        const n = this._getKeyPrefixArray(e);
+        const i = e => typeof e.expires === "number" && Date.now() > e.expires;
+        this.hooks.trigger("preGetMany", {
+            keys: n
+        });
+        if (r.getMany === void 0) {
+            const e = n.map((async e => {
+                const n = await r.get(e);
+                const s = typeof n === "string" || this.opts.compression ? await this.deserializeData(n) : n;
+                if (s === void 0 || s === null) {
+                    return void 0;
+                }
+                if (i(s)) {
+                    await this.delete(e);
+                    return void 0;
+                }
+                return t?.raw ? s : s.value;
+            }));
+            const s = await Promise.allSettled(e);
+            const o = s.map((e => e.value));
+            this.hooks.trigger("postGetMany", o);
+            if (o.length > 0) {
+                this.stats.hit();
+            }
+            return o;
+        }
+        const s = await r.getMany(n);
+        const o = [];
+        for (const r in s) {
+            let n = s[r];
+            if (typeof n === "string") {
+                n = await this.deserializeData(n);
+            }
+            if (n === void 0 || n === null) {
+                o.push(void 0);
+                continue;
+            }
+            if (i(n)) {
+                await this.delete(e[r]);
+                o.push(void 0);
+                continue;
+            }
+            const c = t?.raw ? n : n.value;
+            o.push(c);
+        }
+        this.hooks.trigger("postGetMany", o);
+        if (o.length > 0) {
+            this.stats.hit();
+        }
+        return o;
+    }
+    async set(e, t, r) {
+        const n = {
+            key: e,
+            value: t,
+            ttl: r
+        };
+        this.hooks.trigger("preSet", n);
+        const i = this._getKeyPrefix(n.key);
+        n.ttl ??= this._ttl;
+        if (n.ttl === 0) {
+            n.ttl = void 0;
+        }
+        const {store: s} = this.opts;
+        const o = typeof n.ttl === "number" ? Date.now() + n.ttl : void 0;
+        if (typeof n.value === "symbol") {
+            this.emit("error", "symbol cannot be serialized");
+            throw new Error("symbol cannot be serialized");
+        }
+        const c = {
+            value: n.value,
+            expires: o
+        };
+        const a = await this.serializeData(c);
+        let f = true;
+        try {
+            const e = await s.set(i, a, n.ttl);
+            if (typeof e === "boolean") {
+                f = e;
+            }
+        } catch (e) {
+            f = false;
+            this.emit("error", e);
+        }
+        this.hooks.trigger("postSet", {
+            key: i,
+            value: a,
+            ttl: r
+        });
+        this.stats.set();
+        return f;
+    }
+    async setMany(e) {
+        let t = [];
+        try {
+            if (this._store.setMany !== void 0) {
+                const r = await Promise.all(e.map((async ({key: e, value: t, ttl: r}) => {
+                    r ??= this._ttl;
+                    if (r === 0) {
+                        r = void 0;
+                    }
+                    const n = typeof r === "number" ? Date.now() + r : void 0;
+                    if (typeof t === "symbol") {
+                        this.emit("error", "symbol cannot be serialized");
+                        throw new Error("symbol cannot be serialized");
+                    }
+                    const i = {
+                        value: t,
+                        expires: n
+                    };
+                    const s = await this.serializeData(i);
+                    return {
+                        key: e,
+                        value: s,
+                        ttl: r
+                    };
+                })));
+                t = await this._store.setMany(r);
+            }
+            const r = [];
+            for (const t of e) {
+                r.push(this.set(t.key, t.value, t.ttl));
+            }
+            const n = await Promise.allSettled(r);
+            t = n.map((e => e.value));
+        } catch (r) {
+            this.emit("error", r);
+            t = e.map((() => false));
+        }
+        return t;
+    }
+    async delete(e) {
+        const {store: t} = this.opts;
+        if (Array.isArray(e)) {
+            return this.deleteMany(e);
+        }
+        const r = this._getKeyPrefix(e);
+        this.hooks.trigger("preDelete", {
+            key: r
+        });
+        let n = true;
+        try {
+            const e = await t.delete(r);
+            if (typeof e === "boolean") {
+                n = e;
+            }
+        } catch (e) {
+            n = false;
+            this.emit("error", e);
+        }
+        this.hooks.trigger("postDelete", {
+            key: r,
+            value: n
+        });
+        this.stats.delete();
+        return n;
+    }
+    async deleteMany(e) {
+        try {
+            const {store: t} = this.opts;
+            const r = this._getKeyPrefixArray(e);
+            this.hooks.trigger("preDelete", {
+                key: r
+            });
+            if (t.deleteMany !== void 0) {
+                return await t.deleteMany(r);
+            }
+            const n = r.map((async e => t.delete(e)));
+            const i = await Promise.allSettled(n);
+            const s = i.every((e => e.value === true));
+            this.hooks.trigger("postDelete", {
+                key: r,
+                value: s
+            });
+            return s;
+        } catch (e) {
+            this.emit("error", e);
+            return false;
+        }
+    }
+    async clear() {
+        this.emit("clear");
+        const {store: e} = this.opts;
+        try {
+            await e.clear();
+        } catch (e) {
+            this.emit("error", e);
+        }
+    }
+    async has(e) {
+        if (Array.isArray(e)) {
+            return this.hasMany(e);
+        }
+        const t = this._getKeyPrefix(e);
+        const {store: r} = this.opts;
+        if (r.has !== void 0 && !(r instanceof Map)) {
+            return r.has(t);
+        }
+        let n;
+        try {
+            n = await r.get(t);
+        } catch (e) {
+            this.emit("error", e);
+        }
+        if (n) {
+            const e = await this.deserializeData(n);
+            if (e) {
+                if (e.expires === void 0 || e.expires === null) {
+                    return true;
+                }
+                return e.expires > Date.now();
+            }
+        }
+        return false;
+    }
+    async hasMany(e) {
+        const t = this._getKeyPrefixArray(e);
+        const {store: r} = this.opts;
+        if (r.hasMany !== void 0) {
+            return r.hasMany(t);
+        }
+        const n = [];
+        for (const e of t) {
+            n.push(await this.has(e));
+        }
+        return n;
+    }
+    async disconnect() {
+        const {store: e} = this.opts;
+        this.emit("disconnect");
+        if (typeof e.disconnect === "function") {
+            return e.disconnect();
+        }
+    }
+    emit(e, ...t) {
+        if (e === "error" && !this.opts.emitErrors) {
+            return;
+        }
+        super.emit(e, ...t);
+    }
+    async serializeData(e) {
+        if (!this._serialize) {
+            return e;
+        }
+        if (this._compression?.compress) {
+            return this._serialize({
+                value: await this._compression.compress(e.value),
+                expires: e.expires
+            });
+        }
+        return this._serialize(e);
+    }
+    async deserializeData(e) {
+        if (!this._deserialize) {
+            return e;
+        }
+        if (this._compression?.decompress && typeof e === "string") {
+            const t = await this._deserialize(e);
+            return {
+                value: await this._compression.decompress(t?.value),
+                expires: t?.expires
+            };
+        }
+        if (typeof e === "string") {
+            return this._deserialize(e);
+        }
+        return void 0;
+    }
+};
+
+var F = M;
+
+var N = new Map;
+
+function T(e) {
+    return N.has(e);
+}
+
+function L(e) {
+    N.set(e, []);
+}
+
+function R(e) {
+    N.delete(e);
+}
+
+function I(e, t) {
+    const r = z(e);
+    r.push(t);
+    N.set(e, r);
+}
+
+function z(e) {
+    return N.get(e) ?? [];
+}
+
+async function A(e) {
+    return new Promise(((t, r) => {
+        const n = {
+            resolve: t,
+            reject: r
+        };
+        I(e, n);
+    }));
+}
+
+function C(e) {
+    const t = z(e);
+    R(e);
+    return t;
+}
+
+function K(e) {
+    const {key: t, error: r, result: n} = e;
+    for (const e of C(t)) {
+        if (r) {
+            e.reject(r);
+        } else {
+            e.resolve(n);
+        }
+    }
+}
+
+async function q(e, t) {
+    if (!T(e)) {
+        L(e);
+        try {
+            const r = await Promise.resolve(t());
+            K({
+                key: e,
+                result: r
+            });
+            return r;
+        } catch (t) {
+            K({
+                key: e,
+                error: t
+            });
+            throw t;
+        }
+    }
+    return A(e);
+}
+
+function J(e) {
+    return e !== null && typeof e === "object" && !Array.isArray(e);
+}
+
+function W(e, ...t) {
+    return typeof e === "function" ? e(...t) : e;
+}
+
+function $(e, t) {
+    return typeof e === "number" && typeof t === "number" ? e < t : false;
+}
+
+var B = class {
+    opts;
+    namespace;
+    _cache;
+    constructor(e) {
+        this._cache = e;
+    }
+    async get(e) {
+        const t = await this._cache.get(e);
+        if (t !== void 0 && t !== null) {
+            return t;
+        }
+        return void 0;
+    }
+    async set(e, t, r) {
+        await this._cache.set(e, t, r);
+        return true;
+    }
+    async delete(e) {
+        await this._cache.del(e);
+        return true;
+    }
+    async clear() {
+        return this._cache.reset?.();
+    }
+    async has(e) {
+        const t = await this._cache.get(e);
+        if (t) {
+            return true;
+        }
+        return false;
+    }
+    async getMany(e) {
+        return this._cache.mget(...e).then((e => e.map((e => e))));
+    }
+    async deleteMany(e) {
+        await this._cache.mdel(...e);
+        return true;
+    }
+    on(e, t) {
+        this._cache.on?.(e, t);
+        return this;
+    }
+    async disconnect() {
+        await (this._cache.disconnect?.());
+    }
+};
+
+var G = e => {
+    const t = new r;
+    const n = new M;
+    n.serialize = void 0;
+    n.deserialize = void 0;
+    const i = e?.stores?.length ? e.stores : [ n ];
+    const s = e?.nonBlocking ?? false;
+    const o = e?.cacheId ?? Math.random().toString(36).slice(2);
+    const c = async e => {
+        let r;
+        if (s) {
+            try {
+                r = await Promise.race(i.map((async t => t.get(e))));
+                if (r === void 0) {
+                    return void 0;
+                }
+            } catch (r) {
+                t.emit("get", {
+                    key: e,
+                    error: r
+                });
+            }
+        } else {
+            for (const n of i) {
+                try {
+                    const i = await n.get(e);
+                    if (i !== void 0) {
+                        r = i;
+                        t.emit("get", {
+                            key: e,
+                            value: r
+                        });
+                        break;
+                    }
+                } catch (r) {
+                    t.emit("get", {
+                        key: e,
+                        error: r
+                    });
+                }
+            }
+        }
+        return r;
+    };
+    const a = async e => {
+        const t = [];
+        for (const r of e) {
+            const e = await c(r);
+            t.push(e);
+        }
+        return t;
+    };
+    const f = async e => {
+        let r;
+        if (s) {
+            try {
+                r = await Promise.race(i.map((async t => t.get(e, {
+                    raw: true
+                }))));
+                if (r === void 0) {
+                    return void 0;
+                }
+            } catch (r) {
+                t.emit("ttl", {
+                    key: e,
+                    error: r
+                });
+            }
+        } else {
+            for (const n of i) {
+                try {
+                    const i = await n.get(e, {
+                        raw: true
+                    });
+                    if (i !== void 0) {
+                        r = i;
+                        t.emit("ttl", {
+                            key: e,
+                            value: r
+                        });
+                        break;
+                    }
+                } catch (r) {
+                    t.emit("ttl", {
+                        key: e,
+                        error: r
+                    });
+                }
+            }
+        }
+        if (r?.expires) {
+            return r.expires;
+        }
+        return void 0;
+    };
+    const u = async (r, n, i, o) => {
+        try {
+            if (s) {
+                Promise.all(r.map((async t => t.set(n, i, o ?? e?.ttl))));
+                t.emit("set", {
+                    key: n,
+                    value: i
+                });
+                return i;
+            }
+            await Promise.all(r.map((async t => t.set(n, i, o ?? e?.ttl))));
+            t.emit("set", {
+                key: n,
+                value: i
+            });
+            return i;
+        } catch (e) {
+            t.emit("set", {
+                key: n,
+                value: i,
+                error: e
+            });
+            return Promise.reject(e);
+        }
+    };
+    const l = async (e, r) => {
+        const n = r.map((({key: e, value: t, ttl: r}) => ({
+            key: e,
+            value: t,
+            ttl: r
+        })));
+        try {
+            const n = [];
+            for (const t of r) {
+                n.push(...e.map((async e => e.set(t.key, t.value, t.ttl))));
+            }
+            if (s) {
+                Promise.all(n);
+                t.emit("mset", {
+                    list: r
+                });
+                return r;
+            }
+            await Promise.all(n);
+            t.emit("mset", {
+                list: r
+            });
+            return r;
+        } catch (e) {
+            t.emit("mset", {
+                list: r,
+                error: e
+            });
+            return Promise.reject(e);
+        }
+    };
+    const h = async e => {
+        try {
+            if (s) {
+                Promise.all(i.map((async t => t.delete(e))));
+                t.emit("del", {
+                    key: e
+                });
+                return true;
+            }
+            await Promise.all(i.map((async t => t.delete(e))));
+            t.emit("del", {
+                key: e
+            });
+            return true;
+        } catch (r) {
+            t.emit("del", {
+                key: e,
+                error: r
+            });
+            return Promise.reject(r);
+        }
+    };
+    const p = async e => {
+        try {
+            const r = [];
+            for (const t of e) {
+                r.push(...i.map((async e => e.delete(t))));
+            }
+            if (s) {
+                Promise.all(r);
+                t.emit("mdel", {
+                    keys: e
+                });
+                return true;
+            }
+            await Promise.all(r);
+            t.emit("mdel", {
+                keys: e
+            });
+            return true;
+        } catch (r) {
+            t.emit("mdel", {
+                keys: e,
+                error: r
+            });
+            return Promise.reject(r);
+        }
+    };
+    const y = async () => {
+        try {
+            if (s) {
+                Promise.all(i.map((async e => e.clear())));
+                t.emit("clear");
+                return true;
+            }
+            await Promise.all(i.map((async e => e.clear())));
+            t.emit("clear");
+            return true;
+        } catch (e) {
+            t.emit("clear", e);
+            return Promise.reject(e);
+        }
+    };
+    const d = async (r, n, s, c) => q(`${o}::${r}`, (async () => {
+        let a;
+        let f;
+        let l = 0;
+        let h;
+        const {ttl: p, refreshThreshold: y, raw: d} = J(s) ? s : {
+            ttl: s,
+            refreshThreshold: c
+        };
+        const m = t => W(p, t) ?? e?.ttl;
+        for (;l < i.length; l++) {
+            try {
+                const e = await i[l].get(r, {
+                    raw: true
+                });
+                if (e !== void 0) {
+                    a = e.value;
+                    f = e;
+                    if (typeof e.expires === "number") {
+                        h = Math.max(0, e.expires - Date.now());
+                    }
+                    break;
+                }
+            } catch {}
+        }
+        if (a === void 0) {
+            const e = await n();
+            const t = m(e);
+            await u(i, r, e, t);
+            return d ? {
+                value: e,
+                expires: Date.now() + t
+            } : e;
+        }
+        const v = $(h, W(y, a) ?? e?.refreshThreshold);
+        if (v) {
+            q(`+++${o}__${r}`, n).then((async n => {
+                try {
+                    await u(e?.refreshAllStores ? i : i.slice(0, l + 1), r, n, m(n));
+                    t.emit("refresh", {
+                        key: r,
+                        value: n
+                    });
+                } catch (e) {
+                    t.emit("refresh", {
+                        key: r,
+                        value: a,
+                        error: e
+                    });
+                }
+            })).catch((e => {
+                t.emit("refresh", {
+                    key: r,
+                    value: a,
+                    error: e
+                });
+            }));
+        }
+        if (!v && l > 0) {
+            await u(i.slice(0, l), r, a, m(a));
+        }
+        return d ? f : a;
+    }));
+    const m = (e, r) => t.addListener(e, r);
+    const v = (e, r) => t.removeListener(e, r);
+    const w = async () => {
+        try {
+            await Promise.all(i.map((async e => e.disconnect())));
+        } catch (e) {
+            return Promise.reject(e);
+        }
+    };
+    const S = () => o;
+    return {
+        get: c,
+        mget: a,
+        ttl: f,
+        set: async (e, t, r) => u(i, e, t, r),
+        mset: async e => l(i, e),
+        del: h,
+        mdel: p,
+        clear: y,
+        wrap: d,
+        on: m,
+        off: v,
+        disconnect: w,
+        cacheId: S,
+        stores: i
+    };
+};
+
+var U = {};
+
+var Y;
+
+var H;
+
+function V() {
+    if (H) return Y;
+    H = 1;
+    "use strict";
+    function e() {
+        const e = [].slice.call(arguments).filter((e => e));
+        const t = e.shift();
+        e.forEach((e => {
+            Object.keys(e).forEach((r => {
+                t[r] = e[r];
+            }));
+        }));
+        return t;
+    }
+    Y = e;
+    return Y;
+}
+
+var X = {};
+
+var Q = {};
+
+var Z;
+
+function ee() {
+    if (Z) return Q;
+    Z = 1;
+    "use strict";
+    Q.fromCallback = function(e) {
+        return Object.defineProperty((function() {
+            if (typeof arguments[arguments.length - 1] === "function") e.apply(this, arguments); else {
+                return new Promise(((t, r) => {
+                    arguments[arguments.length] = (e, n) => {
+                        if (e) return r(e);
+                        t(n);
+                    };
+                    arguments.length++;
+                    e.apply(this, arguments);
+                }));
+            }
+        }), "name", {
+            value: e.name
+        });
+    };
+    Q.fromPromise = function(e) {
+        return Object.defineProperty((function() {
+            const t = arguments[arguments.length - 1];
+            if (typeof t !== "function") return e.apply(this, arguments); else e.apply(this, arguments).then((e => t(null, e)), t);
+        }), "name", {
+            value: e.name
+        });
+    };
+    return Q;
+}
+
+var te;
+
+var re;
+
+function ne() {
+    if (re) return te;
+    re = 1;
+    var e = a;
+    var t = process.cwd;
+    var r = null;
+    var n = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+        if (!r) r = t.call(process);
+        return r;
+    };
+    try {
+        process.cwd();
+    } catch (e) {}
+    if (typeof process.chdir === "function") {
+        var i = process.chdir;
+        process.chdir = function(e) {
+            r = null;
+            i.call(process, e);
+        };
+        if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, i);
+    }
+    te = s;
+    function s(t) {
+        if (e.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+            r(t);
+        }
+        if (!t.lutimes) {
+            i(t);
+        }
+        t.chown = c(t.chown);
+        t.fchown = c(t.fchown);
+        t.lchown = c(t.lchown);
+        t.chmod = s(t.chmod);
+        t.fchmod = s(t.fchmod);
+        t.lchmod = s(t.lchmod);
+        t.chownSync = a(t.chownSync);
+        t.fchownSync = a(t.fchownSync);
+        t.lchownSync = a(t.lchownSync);
+        t.chmodSync = o(t.chmodSync);
+        t.fchmodSync = o(t.fchmodSync);
+        t.lchmodSync = o(t.lchmodSync);
+        t.stat = f(t.stat);
+        t.fstat = f(t.fstat);
+        t.lstat = f(t.lstat);
+        t.statSync = u(t.statSync);
+        t.fstatSync = u(t.fstatSync);
+        t.lstatSync = u(t.lstatSync);
+        if (t.chmod && !t.lchmod) {
+            t.lchmod = function(e, t, r) {
+                if (r) process.nextTick(r);
+            };
+            t.lchmodSync = function() {};
+        }
+        if (t.chown && !t.lchown) {
+            t.lchown = function(e, t, r, n) {
+                if (n) process.nextTick(n);
+            };
+            t.lchownSync = function() {};
+        }
+        if (n === "win32") {
+            t.rename = typeof t.rename !== "function" ? t.rename : function(e) {
+                function r(r, n, i) {
+                    var s = Date.now();
+                    var o = 0;
+                    e(r, n, (function c(a) {
+                        if (a && (a.code === "EACCES" || a.code === "EPERM" || a.code === "EBUSY") && Date.now() - s < 6e4) {
+                            setTimeout((function() {
+                                t.stat(n, (function(t, s) {
+                                    if (t && t.code === "ENOENT") e(r, n, c); else i(a);
+                                }));
+                            }), o);
+                            if (o < 100) o += 10;
+                            return;
+                        }
+                        if (i) i(a);
+                    }));
+                }
+                if (Object.setPrototypeOf) Object.setPrototypeOf(r, e);
+                return r;
+            }(t.rename);
+        }
+        t.read = typeof t.read !== "function" ? t.read : function(e) {
+            function r(r, n, i, s, o, c) {
+                var a;
+                if (c && typeof c === "function") {
+                    var f = 0;
+                    a = function(u, l, h) {
+                        if (u && u.code === "EAGAIN" && f < 10) {
+                            f++;
+                            return e.call(t, r, n, i, s, o, a);
+                        }
+                        c.apply(this, arguments);
+                    };
+                }
+                return e.call(t, r, n, i, s, o, a);
+            }
+            if (Object.setPrototypeOf) Object.setPrototypeOf(r, e);
+            return r;
+        }(t.read);
+        t.readSync = typeof t.readSync !== "function" ? t.readSync : function(e) {
+            return function(r, n, i, s, o) {
+                var c = 0;
+                while (true) {
+                    try {
+                        return e.call(t, r, n, i, s, o);
+                    } catch (e) {
+                        if (e.code === "EAGAIN" && c < 10) {
+                            c++;
+                            continue;
+                        }
+                        throw e;
+                    }
+                }
+            };
+        }(t.readSync);
+        function r(t) {
+            t.lchmod = function(r, n, i) {
+                t.open(r, e.O_WRONLY | e.O_SYMLINK, n, (function(e, r) {
+                    if (e) {
+                        if (i) i(e);
+                        return;
+                    }
+                    t.fchmod(r, n, (function(e) {
+                        t.close(r, (function(t) {
+                            if (i) i(e || t);
+                        }));
+                    }));
+                }));
+            };
+            t.lchmodSync = function(r, n) {
+                var i = t.openSync(r, e.O_WRONLY | e.O_SYMLINK, n);
+                var s = true;
+                var o;
+                try {
+                    o = t.fchmodSync(i, n);
+                    s = false;
+                } finally {
+                    if (s) {
+                        try {
+                            t.closeSync(i);
+                        } catch (e) {}
+                    } else {
+                        t.closeSync(i);
+                    }
+                }
+                return o;
+            };
+        }
+        function i(t) {
+            if (e.hasOwnProperty("O_SYMLINK") && t.futimes) {
+                t.lutimes = function(r, n, i, s) {
+                    t.open(r, e.O_SYMLINK, (function(e, r) {
+                        if (e) {
+                            if (s) s(e);
+                            return;
+                        }
+                        t.futimes(r, n, i, (function(e) {
+                            t.close(r, (function(t) {
+                                if (s) s(e || t);
+                            }));
+                        }));
+                    }));
+                };
+                t.lutimesSync = function(r, n, i) {
+                    var s = t.openSync(r, e.O_SYMLINK);
+                    var o;
+                    var c = true;
+                    try {
+                        o = t.futimesSync(s, n, i);
+                        c = false;
+                    } finally {
+                        if (c) {
+                            try {
+                                t.closeSync(s);
+                            } catch (e) {}
+                        } else {
+                            t.closeSync(s);
+                        }
+                    }
+                    return o;
+                };
+            } else if (t.futimes) {
+                t.lutimes = function(e, t, r, n) {
+                    if (n) process.nextTick(n);
+                };
+                t.lutimesSync = function() {};
+            }
+        }
+        function s(e) {
+            if (!e) return e;
+            return function(r, n, i) {
+                return e.call(t, r, n, (function(e) {
+                    if (l(e)) e = null;
+                    if (i) i.apply(this, arguments);
+                }));
+            };
+        }
+        function o(e) {
+            if (!e) return e;
+            return function(r, n) {
+                try {
+                    return e.call(t, r, n);
+                } catch (e) {
+                    if (!l(e)) throw e;
+                }
+            };
+        }
+        function c(e) {
+            if (!e) return e;
+            return function(r, n, i, s) {
+                return e.call(t, r, n, i, (function(e) {
+                    if (l(e)) e = null;
+                    if (s) s.apply(this, arguments);
+                }));
+            };
+        }
+        function a(e) {
+            if (!e) return e;
+            return function(r, n, i) {
+                try {
+                    return e.call(t, r, n, i);
+                } catch (e) {
+                    if (!l(e)) throw e;
+                }
+            };
+        }
+        function f(e) {
+            if (!e) return e;
+            return function(r, n, i) {
+                if (typeof n === "function") {
+                    i = n;
+                    n = null;
+                }
+                function s(e, t) {
+                    if (t) {
+                        if (t.uid < 0) t.uid += 4294967296;
+                        if (t.gid < 0) t.gid += 4294967296;
+                    }
+                    if (i) i.apply(this, arguments);
+                }
+                return n ? e.call(t, r, n, s) : e.call(t, r, s);
+            };
+        }
+        function u(e) {
+            if (!e) return e;
+            return function(r, n) {
+                var i = n ? e.call(t, r, n) : e.call(t, r);
+                if (i) {
+                    if (i.uid < 0) i.uid += 4294967296;
+                    if (i.gid < 0) i.gid += 4294967296;
+                }
+                return i;
+            };
+        }
+        function l(e) {
+            if (!e) return true;
+            if (e.code === "ENOSYS") return true;
+            var t = !process.getuid || process.getuid() !== 0;
+            if (t) {
+                if (e.code === "EINVAL" || e.code === "EPERM") return true;
+            }
+            return false;
+        }
+    }
+    return te;
+}
+
+var ie;
+
+var se;
+
+function oe() {
+    if (se) return ie;
+    se = 1;
+    var e = f.Stream;
+    ie = t;
+    function t(t) {
+        return {
+            ReadStream: r,
+            WriteStream: n
+        };
+        function r(n, i) {
+            if (!(this instanceof r)) return new r(n, i);
+            e.call(this);
+            var s = this;
+            this.path = n;
+            this.fd = null;
+            this.readable = true;
+            this.paused = false;
+            this.flags = "r";
+            this.mode = 438;
+            this.bufferSize = 64 * 1024;
+            i = i || {};
+            var o = Object.keys(i);
+            for (var c = 0, a = o.length; c < a; c++) {
+                var f = o[c];
+                this[f] = i[f];
+            }
+            if (this.encoding) this.setEncoding(this.encoding);
+            if (this.start !== undefined) {
+                if ("number" !== typeof this.start) {
+                    throw TypeError("start must be a Number");
+                }
+                if (this.end === undefined) {
+                    this.end = Infinity;
+                } else if ("number" !== typeof this.end) {
+                    throw TypeError("end must be a Number");
+                }
+                if (this.start > this.end) {
+                    throw new Error("start must be <= end");
+                }
+                this.pos = this.start;
+            }
+            if (this.fd !== null) {
+                process.nextTick((function() {
+                    s._read();
+                }));
+                return;
+            }
+            t.open(this.path, this.flags, this.mode, (function(e, t) {
+                if (e) {
+                    s.emit("error", e);
+                    s.readable = false;
+                    return;
+                }
+                s.fd = t;
+                s.emit("open", t);
+                s._read();
+            }));
+        }
+        function n(r, i) {
+            if (!(this instanceof n)) return new n(r, i);
+            e.call(this);
+            this.path = r;
+            this.fd = null;
+            this.writable = true;
+            this.flags = "w";
+            this.encoding = "binary";
+            this.mode = 438;
+            this.bytesWritten = 0;
+            i = i || {};
+            var s = Object.keys(i);
+            for (var o = 0, c = s.length; o < c; o++) {
+                var a = s[o];
+                this[a] = i[a];
+            }
+            if (this.start !== undefined) {
+                if ("number" !== typeof this.start) {
+                    throw TypeError("start must be a Number");
+                }
+                if (this.start < 0) {
+                    throw new Error("start must be >= zero");
+                }
+                this.pos = this.start;
+            }
+            this.busy = false;
+            this._queue = [];
+            if (this.fd === null) {
+                this._open = t.open;
+                this._queue.push([ this._open, this.path, this.flags, this.mode, undefined ]);
+                this.flush();
+            }
+        }
+    }
+    return ie;
+}
+
+var ce;
+
+var ae;
+
+function fe() {
+    if (ae) return ce;
+    ae = 1;
+    "use strict";
+    ce = t;
+    var e = Object.getPrototypeOf || function(e) {
+        return e.__proto__;
+    };
+    function t(t) {
+        if (t === null || typeof t !== "object") return t;
+        if (t instanceof Object) var r = {
+            __proto__: e(t)
+        }; else var r = Object.create(null);
+        Object.getOwnPropertyNames(t).forEach((function(e) {
+            Object.defineProperty(r, e, Object.getOwnPropertyDescriptor(t, e));
+        }));
+        return r;
+    }
+    return ce;
+}
+
+var ue;
+
+var le;
+
+function he() {
+    if (le) return ue;
+    le = 1;
+    var e = u;
+    var t = ne();
+    var r = oe();
+    var n = fe();
+    var i = l;
+    var o;
+    var c;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+        o = Symbol.for("graceful-fs.queue");
+        c = Symbol.for("graceful-fs.previous");
+    } else {
+        o = "___graceful-fs.queue";
+        c = "___graceful-fs.previous";
+    }
+    function a() {}
+    function f(e, t) {
+        Object.defineProperty(e, o, {
+            get: function() {
+                return t;
+            }
+        });
+    }
+    var p = a;
+    if (i.debuglog) p = i.debuglog("gfs4"); else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) p = function() {
+        var e = i.format.apply(i, arguments);
+        e = "GFS4: " + e.split(/\n/).join("\nGFS4: ");
+        console.error(e);
+    };
+    if (!e[o]) {
+        var y = s[o] || [];
+        f(e, y);
+        e.close = function(t) {
+            function r(r, n) {
+                return t.call(e, r, (function(e) {
+                    if (!e) {
+                        w();
+                    }
+                    if (typeof n === "function") n.apply(this, arguments);
+                }));
+            }
+            Object.defineProperty(r, c, {
+                value: t
+            });
+            return r;
+        }(e.close);
+        e.closeSync = function(t) {
+            function r(r) {
+                t.apply(e, arguments);
+                w();
+            }
+            Object.defineProperty(r, c, {
+                value: t
+            });
+            return r;
+        }(e.closeSync);
+        if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+            process.on("exit", (function() {
+                p(e[o]);
+                h.equal(e[o].length, 0);
+            }));
+        }
+    }
+    if (!s[o]) {
+        f(s, e[o]);
+    }
+    ue = d(n(e));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !e.__patched) {
+        ue = d(e);
+        e.__patched = true;
+    }
+    function d(e) {
+        t(e);
+        e.gracefulify = d;
+        e.createReadStream = x;
+        e.createWriteStream = P;
+        var n = e.readFile;
+        e.readFile = i;
+        function i(e, t, r) {
+            if (typeof t === "function") r = t, t = null;
+            return i(e, t, r);
+            function i(e, t, r, s) {
+                return n(e, t, (function(n) {
+                    if (n && (n.code === "EMFILE" || n.code === "ENFILE")) m([ i, [ e, t, r ], n, s || Date.now(), Date.now() ]); else {
+                        if (typeof r === "function") r.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var s = e.writeFile;
+        e.writeFile = o;
+        function o(e, t, r, n) {
+            if (typeof r === "function") n = r, r = null;
+            return i(e, t, r, n);
+            function i(e, t, r, n, o) {
+                return s(e, t, r, (function(s) {
+                    if (s && (s.code === "EMFILE" || s.code === "ENFILE")) m([ i, [ e, t, r, n ], s, o || Date.now(), Date.now() ]); else {
+                        if (typeof n === "function") n.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var c = e.appendFile;
+        if (c) e.appendFile = a;
+        function a(e, t, r, n) {
+            if (typeof r === "function") n = r, r = null;
+            return i(e, t, r, n);
+            function i(e, t, r, n, s) {
+                return c(e, t, r, (function(o) {
+                    if (o && (o.code === "EMFILE" || o.code === "ENFILE")) m([ i, [ e, t, r, n ], o, s || Date.now(), Date.now() ]); else {
+                        if (typeof n === "function") n.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var f = e.copyFile;
+        if (f) e.copyFile = u;
+        function u(e, t, r, n) {
+            if (typeof r === "function") {
+                n = r;
+                r = 0;
+            }
+            return i(e, t, r, n);
+            function i(e, t, r, n, s) {
+                return f(e, t, r, (function(o) {
+                    if (o && (o.code === "EMFILE" || o.code === "ENFILE")) m([ i, [ e, t, r, n ], o, s || Date.now(), Date.now() ]); else {
+                        if (typeof n === "function") n.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var l = e.readdir;
+        e.readdir = p;
+        var h = /^v[0-5]\./;
+        function p(e, t, r) {
+            if (typeof t === "function") r = t, t = null;
+            var n = h.test(process.version) ? function e(t, r, n, s) {
+                return l(t, i(t, r, n, s));
+            } : function e(t, r, n, s) {
+                return l(t, r, i(t, r, n, s));
+            };
+            return n(e, t, r);
+            function i(e, t, r, i) {
+                return function(s, o) {
+                    if (s && (s.code === "EMFILE" || s.code === "ENFILE")) m([ n, [ e, t, r ], s, i || Date.now(), Date.now() ]); else {
+                        if (o && o.sort) o.sort();
+                        if (typeof r === "function") r.call(this, s, o);
+                    }
+                };
+            }
+        }
+        if (process.version.substr(0, 4) === "v0.8") {
+            var y = r(e);
+            k = y.ReadStream;
+            _ = y.WriteStream;
+        }
+        var v = e.ReadStream;
+        if (v) {
+            k.prototype = Object.create(v.prototype);
+            k.prototype.open = E;
+        }
+        var w = e.WriteStream;
+        if (w) {
+            _.prototype = Object.create(w.prototype);
+            _.prototype.open = b;
+        }
+        Object.defineProperty(e, "ReadStream", {
+            get: function() {
+                return k;
+            },
+            set: function(e) {
+                k = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(e, "WriteStream", {
+            get: function() {
+                return _;
+            },
+            set: function(e) {
+                _ = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        var S = k;
+        Object.defineProperty(e, "FileReadStream", {
+            get: function() {
+                return S;
+            },
+            set: function(e) {
+                S = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        var g = _;
+        Object.defineProperty(e, "FileWriteStream", {
+            get: function() {
+                return g;
+            },
+            set: function(e) {
+                g = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        function k(e, t) {
+            if (this instanceof k) return v.apply(this, arguments), this; else return k.apply(Object.create(k.prototype), arguments);
+        }
+        function E() {
+            var e = this;
+            D(e.path, e.flags, e.mode, (function(t, r) {
+                if (t) {
+                    if (e.autoClose) e.destroy();
+                    e.emit("error", t);
+                } else {
+                    e.fd = r;
+                    e.emit("open", r);
+                    e.read();
+                }
+            }));
+        }
+        function _(e, t) {
+            if (this instanceof _) return w.apply(this, arguments), this; else return _.apply(Object.create(_.prototype), arguments);
+        }
+        function b() {
+            var e = this;
+            D(e.path, e.flags, e.mode, (function(t, r) {
+                if (t) {
+                    e.destroy();
+                    e.emit("error", t);
+                } else {
+                    e.fd = r;
+                    e.emit("open", r);
+                }
+            }));
+        }
+        function x(t, r) {
+            return new e.ReadStream(t, r);
+        }
+        function P(t, r) {
+            return new e.WriteStream(t, r);
+        }
+        var O = e.open;
+        e.open = D;
+        function D(e, t, r, n) {
+            if (typeof r === "function") n = r, r = null;
+            return i(e, t, r, n);
+            function i(e, t, r, n, s) {
+                return O(e, t, r, (function(o, c) {
+                    if (o && (o.code === "EMFILE" || o.code === "ENFILE")) m([ i, [ e, t, r, n ], o, s || Date.now(), Date.now() ]); else {
+                        if (typeof n === "function") n.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        return e;
+    }
+    function m(t) {
+        p("ENQUEUE", t[0].name, t[1]);
+        e[o].push(t);
+        S();
+    }
+    var v;
+    function w() {
+        var t = Date.now();
+        for (var r = 0; r < e[o].length; ++r) {
+            if (e[o][r].length > 2) {
+                e[o][r][3] = t;
+                e[o][r][4] = t;
+            }
+        }
+        S();
+    }
+    function S() {
+        clearTimeout(v);
+        v = undefined;
+        if (e[o].length === 0) return;
+        var t = e[o].shift();
+        var r = t[0];
+        var n = t[1];
+        var i = t[2];
+        var s = t[3];
+        var c = t[4];
+        if (s === undefined) {
+            p("RETRY", r.name, n);
+            r.apply(null, n);
+        } else if (Date.now() - s >= 6e4) {
+            p("TIMEOUT", r.name, n);
+            var a = n.pop();
+            if (typeof a === "function") a.call(null, i);
+        } else {
+            var f = Date.now() - c;
+            var u = Math.max(c - s, 1);
+            var l = Math.min(u * 1.2, 100);
+            if (f >= l) {
+                p("RETRY", r.name, n);
+                r.apply(null, n.concat([ s ]));
+            } else {
+                e[o].push(t);
+            }
+        }
+        if (v === undefined) {
+            v = setTimeout(S, 0);
+        }
+    }
+    return ue;
+}
+
+var pe;
+
+function ye() {
+    if (pe) return X;
+    pe = 1;
+    (function(e) {
+        const t = ee().fromCallback;
+        const r = he();
+        const n = [ "access", "appendFile", "chmod", "chown", "close", "copyFile", "fchmod", "fchown", "fdatasync", "fstat", "fsync", "ftruncate", "futimes", "lchown", "link", "lstat", "mkdir", "mkdtemp", "open", "readFile", "readdir", "readlink", "realpath", "rename", "rmdir", "stat", "symlink", "truncate", "unlink", "utimes", "writeFile" ].filter((e => typeof r[e] === "function"));
+        Object.keys(r).forEach((t => {
+            e[t] = r[t];
+        }));
+        n.forEach((n => {
+            e[n] = t(r[n]);
+        }));
+        e.exists = function(e, t) {
+            if (typeof t === "function") {
+                return r.exists(e, t);
+            }
+            return new Promise((t => r.exists(e, t)));
+        };
+        e.read = function(e, t, n, i, s, o) {
+            if (typeof o === "function") {
+                return r.read(e, t, n, i, s, o);
+            }
+            return new Promise(((o, c) => {
+                r.read(e, t, n, i, s, ((e, t, r) => {
+                    if (e) return c(e);
+                    o({
+                        bytesRead: t,
+                        buffer: r
+                    });
+                }));
+            }));
+        };
+        e.write = function(e, t, n, i, s, o) {
+            if (typeof arguments[arguments.length - 1] === "function") {
+                return r.write(e, t, n, i, s, o);
+            }
+            if (typeof t === "string") {
+                return new Promise(((s, o) => {
+                    r.write(e, t, n, i, ((e, t, r) => {
+                        if (e) return o(e);
+                        s({
+                            bytesWritten: t,
+                            buffer: r
+                        });
+                    }));
+                }));
+            }
+            return new Promise(((o, c) => {
+                r.write(e, t, n, i, s, ((e, t, r) => {
+                    if (e) return c(e);
+                    o({
+                        bytesWritten: t,
+                        buffer: r
+                    });
+                }));
+            }));
+        };
+    })(X);
+    return X;
+}
+
+var de;
+
+var me;
+
+function ve() {
+    if (me) return de;
+    me = 1;
+    "use strict";
+    const e = he();
+    const t = p;
+    const r = y;
+    function n() {
+        let n = r.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
+        n = r.join(t.tmpdir(), n);
+        const i = new Date(1435410243862);
+        e.writeFileSync(n, "https://github.com/jprichardson/node-fs-extra/pull/141");
+        const s = e.openSync(n, "r+");
+        e.futimesSync(s, i, i);
+        e.closeSync(s);
+        return e.statSync(n).mtime > 1435410243e3;
+    }
+    function i(n) {
+        let i = r.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
+        i = r.join(t.tmpdir(), i);
+        const s = new Date(1435410243862);
+        e.writeFile(i, "https://github.com/jprichardson/node-fs-extra/pull/141", (t => {
+            if (t) return n(t);
+            e.open(i, "r+", ((t, r) => {
+                if (t) return n(t);
+                e.futimes(r, s, s, (t => {
+                    if (t) return n(t);
+                    e.close(r, (t => {
+                        if (t) return n(t);
+                        e.stat(i, ((e, t) => {
+                            if (e) return n(e);
+                            n(null, t.mtime > 1435410243e3);
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }
+    function s(e) {
+        if (typeof e === "number") {
+            return Math.floor(e / 1e3) * 1e3;
+        } else if (e instanceof Date) {
+            return new Date(Math.floor(e.getTime() / 1e3) * 1e3);
+        } else {
+            throw new Error("fs-extra: timeRemoveMillis() unknown parameter type");
+        }
+    }
+    function o(t, r, n, i) {
+        e.open(t, "r+", ((t, s) => {
+            if (t) return i(t);
+            e.futimes(s, r, n, (t => {
+                e.close(s, (e => {
+                    if (i) i(t || e);
+                }));
+            }));
+        }));
+    }
+    de = {
+        hasMillisRes: i,
+        hasMillisResSync: n,
+        timeRemoveMillis: s,
+        utimesMillis: o
+    };
+    return de;
+}
+
+var we;
+
+var Se;
+
+function ge() {
+    if (Se) return we;
+    Se = 1;
+    var e = he();
+    var t = y;
+    var r = ve();
+    function n(n, i, s, o) {
+        if (!o) {
+            o = s;
+            s = {};
+        }
+        var c = process.cwd();
+        var a = t.resolve(c, n);
+        var f = t.resolve(c, i);
+        var u = s.filter;
+        var l = s.transform;
+        var h = s.overwrite;
+        if (h === undefined) h = s.clobber;
+        if (h === undefined) h = true;
+        var p = s.errorOnExist;
+        var y = s.dereference;
+        var d = s.preserveTimestamps === true;
+        var m = 0;
+        var v = 0;
+        var w = 0;
+        var S = false;
+        g(a);
+        function g(e) {
+            m++;
+            if (u) {
+                if (u instanceof RegExp) {
+                    console.warn("Warning: fs-extra: Passing a RegExp filter is deprecated, use a function");
+                    if (!u.test(e)) {
+                        return T(true);
+                    }
+                } else if (typeof u === "function") {
+                    if (!u(e, i)) {
+                        return T(true);
+                    }
+                }
+            }
+            return k(e);
+        }
+        function k(t) {
+            var r = y ? e.stat : e.lstat;
+            w++;
+            r(t, (function(e, r) {
+                if (e) return N(e);
+                var n = {
+                    name: t,
+                    mode: r.mode,
+                    mtime: r.mtime,
+                    atime: r.atime,
+                    stats: r
+                };
+                if (r.isDirectory()) {
+                    return x(n);
+                } else if (r.isFile() || r.isCharacterDevice() || r.isBlockDevice()) {
+                    return E(n);
+                } else if (r.isSymbolicLink()) {
+                    return D(t);
+                }
+            }));
+        }
+        function E(e) {
+            var t = e.name.replace(a, f.replace("$", "$$$$"));
+            F(t, (function(r) {
+                if (r) {
+                    _(e, t);
+                } else {
+                    if (h) {
+                        b(t, (function() {
+                            _(e, t);
+                        }));
+                    } else if (p) {
+                        N(new Error(t + " already exists"));
+                    } else {
+                        T();
+                    }
+                }
+            }));
+        }
+        function _(t, n) {
+            var i = e.createReadStream(t.name);
+            var s = e.createWriteStream(n, {
+                mode: t.mode
+            });
+            i.on("error", N);
+            s.on("error", N);
+            if (l) {
+                l(i, s, t);
+            } else {
+                s.on("open", (function() {
+                    i.pipe(s);
+                }));
+            }
+            s.once("close", (function() {
+                e.chmod(n, t.mode, (function(e) {
+                    if (e) return N(e);
+                    if (d) {
+                        r.utimesMillis(n, t.atime, t.mtime, (function(e) {
+                            if (e) return N(e);
+                            return T();
+                        }));
+                    } else {
+                        T();
+                    }
+                }));
+            }));
+        }
+        function b(t, r) {
+            e.unlink(t, (function(e) {
+                if (e) return N(e);
+                return r();
+            }));
+        }
+        function x(e) {
+            var t = e.name.replace(a, f.replace("$", "$$$$"));
+            F(t, (function(r) {
+                if (r) {
+                    return P(e, t);
+                }
+                O(e.name);
+            }));
+        }
+        function P(t, r) {
+            e.mkdir(r, t.mode, (function(n) {
+                if (n) return N(n);
+                e.chmod(r, t.mode, (function(e) {
+                    if (e) return N(e);
+                    O(t.name);
+                }));
+            }));
+        }
+        function O(r) {
+            e.readdir(r, (function(e, n) {
+                if (e) return N(e);
+                n.forEach((function(e) {
+                    g(t.join(r, e));
+                }));
+                return T();
+            }));
+        }
+        function D(t) {
+            var r = t.replace(a, f);
+            e.readlink(t, (function(e, t) {
+                if (e) return N(e);
+                j(t, r);
+            }));
+        }
+        function j(r, n) {
+            if (y) {
+                r = t.resolve(c, r);
+            }
+            F(n, (function(i) {
+                if (i) {
+                    return M(r, n);
+                }
+                e.readlink(n, (function(e, i) {
+                    if (e) return N(e);
+                    if (y) {
+                        i = t.resolve(c, i);
+                    }
+                    if (i === r) {
+                        return T();
+                    }
+                    return b(n, (function() {
+                        M(r, n);
+                    }));
+                }));
+            }));
+        }
+        function M(t, r) {
+            e.symlink(t, r, (function(e) {
+                if (e) return N(e);
+                return T();
+            }));
+        }
+        function F(t, r) {
+            e.lstat(t, (function(e) {
+                if (e) {
+                    if (e.code === "ENOENT") return r(true);
+                    return r(false);
+                }
+                return r(false);
+            }));
+        }
+        function N(e) {
+            if (!S && o !== undefined) {
+                S = true;
+                return o(e);
+            }
+        }
+        function T(e) {
+            if (!e) w--;
+            v++;
+            if (m === v && w === 0) {
+                if (o !== undefined) {
+                    return o(null);
+                }
+            }
+        }
+    }
+    we = n;
+    return we;
+}
+
+var ke;
+
+var Ee;
+
+function _e() {
+    if (Ee) return ke;
+    Ee = 1;
+    "use strict";
+    const e = y;
+    function t(t) {
+        t = e.normalize(e.resolve(t)).split(e.sep);
+        if (t.length > 0) return t[0];
+        return null;
+    }
+    const r = /[<>:"|?*]/;
+    function n(e) {
+        const n = t(e);
+        e = e.replace(n, "");
+        return r.test(e);
+    }
+    ke = {
+        getRootPath: t,
+        invalidWin32Path: n
+    };
+    return ke;
+}
+
+var be;
+
+var xe;
+
+function Pe() {
+    if (xe) return be;
+    xe = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = _e().invalidWin32Path;
+    const n = parseInt("0777", 8);
+    function i(s, o, c, a) {
+        if (typeof o === "function") {
+            c = o;
+            o = {};
+        } else if (!o || typeof o !== "object") {
+            o = {
+                mode: o
+            };
+        }
+        if (process.platform === "win32" && r(s)) {
+            const e = new Error(s + " contains invalid WIN32 path characters.");
+            e.code = "EINVAL";
+            return c(e);
+        }
+        let f = o.mode;
+        const u = o.fs || e;
+        if (f === undefined) {
+            f = n & ~process.umask();
+        }
+        if (!a) a = null;
+        c = c || function() {};
+        s = t.resolve(s);
+        u.mkdir(s, f, (e => {
+            if (!e) {
+                a = a || s;
+                return c(null, a);
+            }
+            switch (e.code) {
+              case "ENOENT":
+                if (t.dirname(s) === s) return c(e);
+                i(t.dirname(s), o, ((e, t) => {
+                    if (e) c(e, t); else i(s, o, c, t);
+                }));
+                break;
+
+              default:
+                u.stat(s, ((t, r) => {
+                    if (t || !r.isDirectory()) c(e, a); else c(null, a);
+                }));
+                break;
+            }
+        }));
+    }
+    be = i;
+    return be;
+}
+
+var Oe;
+
+var De;
+
+function je() {
+    if (De) return Oe;
+    De = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = _e().invalidWin32Path;
+    const n = parseInt("0777", 8);
+    function i(s, o, c) {
+        if (!o || typeof o !== "object") {
+            o = {
+                mode: o
+            };
+        }
+        let a = o.mode;
+        const f = o.fs || e;
+        if (process.platform === "win32" && r(s)) {
+            const e = new Error(s + " contains invalid WIN32 path characters.");
+            e.code = "EINVAL";
+            throw e;
+        }
+        if (a === undefined) {
+            a = n & ~process.umask();
+        }
+        if (!c) c = null;
+        s = t.resolve(s);
+        try {
+            f.mkdirSync(s, a);
+            c = c || s;
+        } catch (e) {
+            switch (e.code) {
+              case "ENOENT":
+                if (t.dirname(s) === s) throw e;
+                c = i(t.dirname(s), o, c);
+                i(s, o, c);
+                break;
+
+              default:
+                let r;
+                try {
+                    r = f.statSync(s);
+                } catch (t) {
+                    throw e;
+                }
+                if (!r.isDirectory()) throw e;
+                break;
+            }
+        }
+        return c;
+    }
+    Oe = i;
+    return Oe;
+}
+
+var Me;
+
+var Fe;
+
+function Ne() {
+    if (Fe) return Me;
+    Fe = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = e(Pe());
+    const r = je();
+    Me = {
+        mkdirs: t,
+        mkdirsSync: r,
+        mkdirp: t,
+        mkdirpSync: r,
+        ensureDir: t,
+        ensureDirSync: r
+    };
+    return Me;
+}
+
+var Te;
+
+var Le;
+
+function Re() {
+    if (Le) return Te;
+    Le = 1;
+    "use strict";
+    const e = ee().fromPromise;
+    const t = ye();
+    function r(e) {
+        return t.access(e).then((() => true)).catch((() => false));
+    }
+    Te = {
+        pathExists: e(r),
+        pathExistsSync: t.existsSync
+    };
+    return Te;
+}
+
+var Ie;
+
+var ze;
+
+function Ae() {
+    if (ze) return Ie;
+    ze = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = ge();
+    const n = Ne();
+    const i = Re().pathExists;
+    function s(s, o, c, a) {
+        if (typeof c === "function" && !a) {
+            a = c;
+            c = {};
+        } else if (typeof c === "function" || c instanceof RegExp) {
+            c = {
+                filter: c
+            };
+        }
+        a = a || function() {};
+        c = c || {};
+        if (c.preserveTimestamps && process.arch === "ia32") {
+            console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n\n    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+        }
+        const f = process.cwd();
+        const u = t.resolve(f, s);
+        const l = t.resolve(f, o);
+        if (u === l) return a(new Error("Source and destination must not be the same."));
+        e.lstat(s, ((e, f) => {
+            if (e) return a(e);
+            let u = null;
+            if (f.isDirectory()) {
+                const e = o.split(t.sep);
+                e.pop();
+                u = e.join(t.sep);
+            } else {
+                u = t.dirname(o);
+            }
+            i(u, ((e, t) => {
+                if (e) return a(e);
+                if (t) return r(s, o, c, a);
+                n.mkdirs(u, (e => {
+                    if (e) return a(e);
+                    r(s, o, c, a);
+                }));
+            }));
+        }));
+    }
+    Ie = s;
+    return Ie;
+}
+
+var Ce;
+
+var Ke;
+
+function qe() {
+    if (Ke) return Ce;
+    Ke = 1;
+    const e = ee().fromCallback;
+    Ce = {
+        copy: e(Ae())
+    };
+    return Ce;
+}
+
+var Je;
+
+var We;
+
+function $e() {
+    if (We) return Je;
+    We = 1;
+    Je = function(e) {
+        if (typeof Buffer.allocUnsafe === "function") {
+            try {
+                return Buffer.allocUnsafe(e);
+            } catch (t) {
+                return new Buffer(e);
+            }
+        }
+        return new Buffer(e);
+    };
+    return Je;
+}
+
+var Be;
+
+var Ge;
+
+function Ue() {
+    if (Ge) return Be;
+    Ge = 1;
+    "use strict";
+    const e = he();
+    const t = 64 * 1024;
+    const r = $e()(t);
+    function n(n, i, s) {
+        const o = s.overwrite;
+        const c = s.errorOnExist;
+        const a = s.preserveTimestamps;
+        if (e.existsSync(i)) {
+            if (o) {
+                e.unlinkSync(i);
+            } else if (c) {
+                throw new Error(`${i} already exists`);
+            } else return;
+        }
+        const f = e.openSync(n, "r");
+        const u = e.fstatSync(f);
+        const l = e.openSync(i, "w", u.mode);
+        let h = 1;
+        let p = 0;
+        while (h > 0) {
+            h = e.readSync(f, r, 0, t, p);
+            e.writeSync(l, r, 0, h);
+            p += h;
+        }
+        if (a) {
+            e.futimesSync(l, u.atime, u.mtime);
+        }
+        e.closeSync(f);
+        e.closeSync(l);
+    }
+    Be = n;
+    return Be;
+}
+
+var Ye;
+
+var He;
+
+function Ve() {
+    if (He) return Ye;
+    He = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = Ue();
+    const n = Ne();
+    function i(s, o, c) {
+        if (typeof c === "function" || c instanceof RegExp) {
+            c = {
+                filter: c
+            };
+        }
+        c = c || {};
+        c.recursive = !!c.recursive;
+        c.clobber = "clobber" in c ? !!c.clobber : true;
+        c.overwrite = "overwrite" in c ? !!c.overwrite : c.clobber;
+        c.dereference = "dereference" in c ? !!c.dereference : false;
+        c.preserveTimestamps = "preserveTimestamps" in c ? !!c.preserveTimestamps : false;
+        c.filter = c.filter || function() {
+            return true;
+        };
+        if (c.preserveTimestamps && process.arch === "ia32") {
+            console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n\n    see https://github.com/jprichardson/node-fs-extra/issues/269`);
+        }
+        const a = c.recursive && !c.dereference ? e.lstatSync(s) : e.statSync(s);
+        const f = t.dirname(o);
+        const u = e.existsSync(f);
+        let l = false;
+        if (c.filter instanceof RegExp) {
+            console.warn("Warning: fs-extra: Passing a RegExp filter is deprecated, use a function");
+            l = c.filter.test(s);
+        } else if (typeof c.filter === "function") l = c.filter(s, o);
+        if (a.isFile() && l) {
+            if (!u) n.mkdirsSync(f);
+            r(s, o, {
+                overwrite: c.overwrite,
+                errorOnExist: c.errorOnExist,
+                preserveTimestamps: c.preserveTimestamps
+            });
+        } else if (a.isDirectory() && l) {
+            if (!e.existsSync(o)) n.mkdirsSync(o);
+            const r = e.readdirSync(s);
+            r.forEach((e => {
+                const r = c;
+                r.recursive = true;
+                i(t.join(s, e), t.join(o, e), r);
+            }));
+        } else if (c.recursive && a.isSymbolicLink() && l) {
+            const t = e.readlinkSync(s);
+            e.symlinkSync(t, o);
+        }
+    }
+    Ye = i;
+    return Ye;
+}
+
+var Xe;
+
+var Qe;
+
+function Ze() {
+    if (Qe) return Xe;
+    Qe = 1;
+    Xe = {
+        copySync: Ve()
+    };
+    return Xe;
+}
+
+var et;
+
+var tt;
+
+function rt() {
+    if (tt) return et;
+    tt = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = h;
+    const n = process.platform === "win32";
+    function i(t) {
+        const r = [ "unlink", "chmod", "stat", "lstat", "rmdir", "readdir" ];
+        r.forEach((r => {
+            t[r] = t[r] || e[r];
+            r = r + "Sync";
+            t[r] = t[r] || e[r];
+        }));
+        t.maxBusyTries = t.maxBusyTries || 3;
+    }
+    function s(e, t, n) {
+        let s = 0;
+        if (typeof t === "function") {
+            n = t;
+            t = {};
+        }
+        r(e, "rimraf: missing path");
+        r.equal(typeof e, "string", "rimraf: path should be a string");
+        r.equal(typeof n, "function", "rimraf: callback function required");
+        r(t, "rimraf: invalid options argument provided");
+        r.equal(typeof t, "object", "rimraf: options should be object");
+        i(t);
+        o(e, t, (function r(i) {
+            if (i) {
+                if ((i.code === "EBUSY" || i.code === "ENOTEMPTY" || i.code === "EPERM") && s < t.maxBusyTries) {
+                    s++;
+                    let n = s * 100;
+                    return setTimeout((() => o(e, t, r)), n);
+                }
+                if (i.code === "ENOENT") i = null;
+            }
+            n(i);
+        }));
+    }
+    function o(e, t, i) {
+        r(e);
+        r(t);
+        r(typeof i === "function");
+        t.lstat(e, ((r, s) => {
+            if (r && r.code === "ENOENT") {
+                return i(null);
+            }
+            if (r && r.code === "EPERM" && n) {
+                return c(e, t, r, i);
+            }
+            if (s && s.isDirectory()) {
+                return f(e, t, r, i);
+            }
+            t.unlink(e, (r => {
+                if (r) {
+                    if (r.code === "ENOENT") {
+                        return i(null);
+                    }
+                    if (r.code === "EPERM") {
+                        return n ? c(e, t, r, i) : f(e, t, r, i);
+                    }
+                    if (r.code === "EISDIR") {
+                        return f(e, t, r, i);
+                    }
+                }
+                return i(r);
+            }));
+        }));
+    }
+    function c(e, t, n, i) {
+        r(e);
+        r(t);
+        r(typeof i === "function");
+        if (n) {
+            r(n instanceof Error);
+        }
+        t.chmod(e, 438, (r => {
+            if (r) {
+                i(r.code === "ENOENT" ? null : n);
+            } else {
+                t.stat(e, ((r, s) => {
+                    if (r) {
+                        i(r.code === "ENOENT" ? null : n);
+                    } else if (s.isDirectory()) {
+                        f(e, t, n, i);
+                    } else {
+                        t.unlink(e, i);
+                    }
+                }));
+            }
+        }));
+    }
+    function a(e, t, n) {
+        let i;
+        r(e);
+        r(t);
+        if (n) {
+            r(n instanceof Error);
+        }
+        try {
+            t.chmodSync(e, 438);
+        } catch (e) {
+            if (e.code === "ENOENT") {
+                return;
+            } else {
+                throw n;
+            }
+        }
+        try {
+            i = t.statSync(e);
+        } catch (e) {
+            if (e.code === "ENOENT") {
+                return;
+            } else {
+                throw n;
+            }
+        }
+        if (i.isDirectory()) {
+            p(e, t, n);
+        } else {
+            t.unlinkSync(e);
+        }
+    }
+    function f(e, t, n, i) {
+        r(e);
+        r(t);
+        if (n) {
+            r(n instanceof Error);
+        }
+        r(typeof i === "function");
+        t.rmdir(e, (r => {
+            if (r && (r.code === "ENOTEMPTY" || r.code === "EEXIST" || r.code === "EPERM")) {
+                u(e, t, i);
+            } else if (r && r.code === "ENOTDIR") {
+                i(n);
+            } else {
+                i(r);
+            }
+        }));
+    }
+    function u(e, n, i) {
+        r(e);
+        r(n);
+        r(typeof i === "function");
+        n.readdir(e, ((r, o) => {
+            if (r) return i(r);
+            let c = o.length;
+            let a;
+            if (c === 0) return n.rmdir(e, i);
+            o.forEach((r => {
+                s(t.join(e, r), n, (t => {
+                    if (a) {
+                        return;
+                    }
+                    if (t) return i(a = t);
+                    if (--c === 0) {
+                        n.rmdir(e, i);
+                    }
+                }));
+            }));
+        }));
+    }
+    function l(e, t) {
+        let s;
+        t = t || {};
+        i(t);
+        r(e, "rimraf: missing path");
+        r.equal(typeof e, "string", "rimraf: path should be a string");
+        r(t, "rimraf: missing options");
+        r.equal(typeof t, "object", "rimraf: options should be object");
+        try {
+            s = t.lstatSync(e);
+        } catch (r) {
+            if (r.code === "ENOENT") {
+                return;
+            }
+            if (r.code === "EPERM" && n) {
+                a(e, t, r);
+            }
+        }
+        try {
+            if (s && s.isDirectory()) {
+                p(e, t, null);
+            } else {
+                t.unlinkSync(e);
+            }
+        } catch (r) {
+            if (r.code === "ENOENT") {
+                return;
+            } else if (r.code === "EPERM") {
+                return n ? a(e, t, r) : p(e, t, r);
+            } else if (r.code !== "EISDIR") {
+                throw r;
+            }
+            p(e, t, r);
+        }
+    }
+    function p(e, t, n) {
+        r(e);
+        r(t);
+        if (n) {
+            r(n instanceof Error);
+        }
+        try {
+            t.rmdirSync(e);
+        } catch (r) {
+            if (r.code === "ENOTDIR") {
+                throw n;
+            } else if (r.code === "ENOTEMPTY" || r.code === "EEXIST" || r.code === "EPERM") {
+                d(e, t);
+            } else if (r.code !== "ENOENT") {
+                throw r;
+            }
+        }
+    }
+    function d(e, i) {
+        r(e);
+        r(i);
+        i.readdirSync(e).forEach((r => l(t.join(e, r), i)));
+        const s = n ? 100 : 1;
+        let o = 0;
+        do {
+            let t = true;
+            try {
+                const r = i.rmdirSync(e, i);
+                t = false;
+                return r;
+            } finally {
+                if (++o < s && t) continue;
+            }
+        } while (true);
+    }
+    et = s;
+    s.sync = l;
+    return et;
+}
+
+var nt;
+
+var it;
+
+function st() {
+    if (it) return nt;
+    it = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = rt();
+    nt = {
+        remove: e(t),
+        removeSync: t.sync
+    };
+    return nt;
+}
+
+var ot;
+
+var ct;
+
+function at() {
+    if (ct) return ot;
+    ct = 1;
+    var e;
+    try {
+        e = he();
+    } catch (t) {
+        e = u;
+    }
+    function t(t, r, n) {
+        if (n == null) {
+            n = r;
+            r = {};
+        }
+        if (typeof r === "string") {
+            r = {
+                encoding: r
+            };
+        }
+        r = r || {};
+        var i = r.fs || e;
+        var s = true;
+        if ("throws" in r) {
+            s = r.throws;
+        }
+        i.readFile(t, r, (function(e, i) {
+            if (e) return n(e);
+            i = o(i);
+            var c;
+            try {
+                c = JSON.parse(i, r ? r.reviver : null);
+            } catch (e) {
+                if (s) {
+                    e.message = t + ": " + e.message;
+                    return n(e);
+                } else {
+                    return n(null, null);
+                }
+            }
+            n(null, c);
+        }));
+    }
+    function r(t, r) {
+        r = r || {};
+        if (typeof r === "string") {
+            r = {
+                encoding: r
+            };
+        }
+        var n = r.fs || e;
+        var i = true;
+        if ("throws" in r) {
+            i = r.throws;
+        }
+        try {
+            var s = n.readFileSync(t, r);
+            s = o(s);
+            return JSON.parse(s, r.reviver);
+        } catch (e) {
+            if (i) {
+                e.message = t + ": " + e.message;
+                throw e;
+            } else {
+                return null;
+            }
+        }
+    }
+    function n(e, t) {
+        var r;
+        var n = "\n";
+        if (typeof t === "object" && t !== null) {
+            if (t.spaces) {
+                r = t.spaces;
+            }
+            if (t.EOL) {
+                n = t.EOL;
+            }
+        }
+        var i = JSON.stringify(e, t ? t.replacer : null, r);
+        return i.replace(/\n/g, n) + n;
+    }
+    function i(t, r, i, s) {
+        if (s == null) {
+            s = i;
+            i = {};
+        }
+        i = i || {};
+        var o = i.fs || e;
+        var c = "";
+        try {
+            c = n(r, i);
+        } catch (e) {
+            if (s) s(e, null);
+            return;
+        }
+        o.writeFile(t, c, i, s);
+    }
+    function s(t, r, i) {
+        i = i || {};
+        var s = i.fs || e;
+        var o = n(r, i);
+        return s.writeFileSync(t, o, i);
+    }
+    function o(e) {
+        if (Buffer.isBuffer(e)) e = e.toString("utf8");
+        e = e.replace(/^\uFEFF/, "");
+        return e;
+    }
+    var c = {
+        readFile: t,
+        readFileSync: r,
+        writeFile: i,
+        writeFileSync: s
+    };
+    ot = c;
+    return ot;
+}
+
+var ft;
+
+var ut;
+
+function lt() {
+    if (ut) return ft;
+    ut = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = at();
+    ft = {
+        readJson: e(t.readFile),
+        readJsonSync: t.readFileSync,
+        writeJson: e(t.writeFile),
+        writeJsonSync: t.writeFileSync
+    };
+    return ft;
+}
+
+var ht;
+
+var pt;
+
+function yt() {
+    if (pt) return ht;
+    pt = 1;
+    "use strict";
+    const e = y;
+    const t = Ne();
+    const r = Re().pathExists;
+    const n = lt();
+    function i(i, s, o, c) {
+        if (typeof o === "function") {
+            c = o;
+            o = {};
+        }
+        const a = e.dirname(i);
+        r(a, ((e, r) => {
+            if (e) return c(e);
+            if (r) return n.writeJson(i, s, o, c);
+            t.mkdirs(a, (e => {
+                if (e) return c(e);
+                n.writeJson(i, s, o, c);
+            }));
+        }));
+    }
+    ht = i;
+    return ht;
+}
+
+var dt;
+
+var mt;
+
+function vt() {
+    if (mt) return dt;
+    mt = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = Ne();
+    const n = lt();
+    function i(i, s, o) {
+        const c = t.dirname(i);
+        if (!e.existsSync(c)) {
+            r.mkdirsSync(c);
+        }
+        n.writeJsonSync(i, s, o);
+    }
+    dt = i;
+    return dt;
+}
+
+var wt;
+
+var St;
+
+function gt() {
+    if (St) return wt;
+    St = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = lt();
+    t.outputJson = e(yt());
+    t.outputJsonSync = vt();
+    t.outputJSON = t.outputJson;
+    t.outputJSONSync = t.outputJsonSync;
+    t.writeJSON = t.writeJson;
+    t.writeJSONSync = t.writeJsonSync;
+    t.readJSON = t.readJson;
+    t.readJSONSync = t.readJsonSync;
+    wt = t;
+    return wt;
+}
+
+var kt;
+
+var Et;
+
+function _t() {
+    if (Et) return kt;
+    Et = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = he();
+    const r = ge();
+    const n = y;
+    const i = st().remove;
+    const s = Ne().mkdirs;
+    function o(e, r, a, f) {
+        if (typeof a === "function") {
+            f = a;
+            a = {};
+        }
+        const l = a.overwrite || a.clobber || false;
+        u(e, r, ((t, i) => {
+            if (t) return f(t);
+            if (i) return f(new Error(`Cannot move '${e}' to a subdirectory of itself, '${r}'.`));
+            s(n.dirname(r), (e => {
+                if (e) return f(e);
+                h();
+            }));
+        }));
+        function h() {
+            if (n.resolve(e) === n.resolve(r)) {
+                t.access(e, f);
+            } else if (l) {
+                t.rename(e, r, (t => {
+                    if (!t) return f();
+                    if (t.code === "ENOTEMPTY" || t.code === "EEXIST") {
+                        i(r, (t => {
+                            if (t) return f(t);
+                            a.overwrite = false;
+                            o(e, r, a, f);
+                        }));
+                        return;
+                    }
+                    if (t.code === "EPERM") {
+                        setTimeout((() => {
+                            i(r, (t => {
+                                if (t) return f(t);
+                                a.overwrite = false;
+                                o(e, r, a, f);
+                            }));
+                        }), 200);
+                        return;
+                    }
+                    if (t.code !== "EXDEV") return f(t);
+                    c(e, r, l, f);
+                }));
+            } else {
+                t.link(e, r, (n => {
+                    if (n) {
+                        if (n.code === "EXDEV" || n.code === "EISDIR" || n.code === "EPERM" || n.code === "ENOTSUP") {
+                            return c(e, r, l, f);
+                        }
+                        return f(n);
+                    }
+                    return t.unlink(e, f);
+                }));
+            }
+        }
+    }
+    function c(e, r, n, i) {
+        t.stat(e, ((t, s) => {
+            if (t) return i(t);
+            if (s.isDirectory()) {
+                f(e, r, n, i);
+            } else {
+                a(e, r, n, i);
+            }
+        }));
+    }
+    function a(e, r, n, i) {
+        const s = n ? "w" : "wx";
+        const o = t.createReadStream(e);
+        const c = t.createWriteStream(r, {
+            flags: s
+        });
+        o.on("error", (s => {
+            o.destroy();
+            c.destroy();
+            c.removeListener("close", a);
+            t.unlink(r, (() => {
+                if (s.code === "EISDIR" || s.code === "EPERM") {
+                    f(e, r, n, i);
+                } else {
+                    i(s);
+                }
+            }));
+        }));
+        c.on("error", (e => {
+            o.destroy();
+            c.destroy();
+            c.removeListener("close", a);
+            i(e);
+        }));
+        c.once("close", a);
+        o.pipe(c);
+        function a() {
+            t.unlink(e, i);
+        }
+    }
+    function f(e, t, n, s) {
+        const o = {
+            overwrite: false
+        };
+        if (n) {
+            i(t, (e => {
+                if (e) return s(e);
+                c();
+            }));
+        } else {
+            c();
+        }
+        function c() {
+            r(e, t, o, (t => {
+                if (t) return s(t);
+                i(e, s);
+            }));
+        }
+    }
+    function u(e, r, i) {
+        t.stat(e, ((t, s) => {
+            if (t) return i(t);
+            if (s.isDirectory()) {
+                const t = r.split(n.dirname(e) + n.sep)[1];
+                if (t) {
+                    const s = t.split(n.sep)[0];
+                    if (s) return i(null, e !== r && r.indexOf(e) > -1 && s === n.basename(e));
+                    return i(null, false);
+                }
+                return i(null, false);
+            }
+            return i(null, false);
+        }));
+    }
+    kt = {
+        move: e(o)
+    };
+    return kt;
+}
+
+var bt;
+
+var xt;
+
+function Pt() {
+    if (xt) return bt;
+    xt = 1;
+    "use strict";
+    const e = he();
+    const t = y;
+    const r = Ze().copySync;
+    const n = st().removeSync;
+    const i = Ne().mkdirsSync;
+    const s = $e();
+    function o(r, s, a) {
+        a = a || {};
+        const f = a.overwrite || a.clobber || false;
+        r = t.resolve(r);
+        s = t.resolve(s);
+        if (r === s) return e.accessSync(r);
+        if (u(r, s)) throw new Error(`Cannot move '${r}' into itself '${s}'.`);
+        i(t.dirname(s));
+        l();
+        function l() {
+            if (f) {
+                try {
+                    return e.renameSync(r, s);
+                } catch (e) {
+                    if (e.code === "ENOTEMPTY" || e.code === "EEXIST" || e.code === "EPERM") {
+                        n(s);
+                        a.overwrite = false;
+                        return o(r, s, a);
+                    }
+                    if (e.code !== "EXDEV") throw e;
+                    return c(r, s, f);
+                }
+            } else {
+                try {
+                    e.linkSync(r, s);
+                    return e.unlinkSync(r);
+                } catch (e) {
+                    if (e.code === "EXDEV" || e.code === "EISDIR" || e.code === "EPERM" || e.code === "ENOTSUP") {
+                        return c(r, s, f);
+                    }
+                    throw e;
+                }
+            }
+        }
+    }
+    function c(t, r, n) {
+        const i = e.statSync(t);
+        if (i.isDirectory()) {
+            return f(t, r, n);
+        } else {
+            return a(t, r, n);
+        }
+    }
+    function a(t, r, n) {
+        const i = 64 * 1024;
+        const o = s(i);
+        const c = n ? "w" : "wx";
+        const a = e.openSync(t, "r");
+        const f = e.fstatSync(a);
+        const u = e.openSync(r, c, f.mode);
+        let l = 1;
+        let h = 0;
+        while (l > 0) {
+            l = e.readSync(a, o, 0, i, h);
+            e.writeSync(u, o, 0, l);
+            h += l;
+        }
+        e.closeSync(a);
+        e.closeSync(u);
+        return e.unlinkSync(t);
+    }
+    function f(e, t, i) {
+        const s = {
+            overwrite: false
+        };
+        if (i) {
+            n(t);
+            o();
+        } else {
+            o();
+        }
+        function o() {
+            r(e, t, s);
+            return n(e);
+        }
+    }
+    function u(r, n) {
+        try {
+            return e.statSync(r).isDirectory() && r !== n && n.indexOf(r) > -1 && n.split(t.dirname(r) + t.sep)[1].split(t.sep)[0] === t.basename(r);
+        } catch (e) {
+            return false;
+        }
+    }
+    bt = {
+        moveSync: o
+    };
+    return bt;
+}
+
+var Ot;
+
+var Dt;
+
+function jt() {
+    if (Dt) return Ot;
+    Dt = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = u;
+    const r = y;
+    const n = Ne();
+    const i = st();
+    const s = e((function e(s, o) {
+        o = o || function() {};
+        t.readdir(s, ((e, t) => {
+            if (e) return n.mkdirs(s, o);
+            t = t.map((e => r.join(s, e)));
+            c();
+            function c() {
+                const e = t.pop();
+                if (!e) return o();
+                i.remove(e, (e => {
+                    if (e) return o(e);
+                    c();
+                }));
+            }
+        }));
+    }));
+    function o(e) {
+        let s;
+        try {
+            s = t.readdirSync(e);
+        } catch (t) {
+            return n.mkdirsSync(e);
+        }
+        s.forEach((t => {
+            t = r.join(e, t);
+            i.removeSync(t);
+        }));
+    }
+    Ot = {
+        emptyDirSync: o,
+        emptydirSync: o,
+        emptyDir: s,
+        emptydir: s
+    };
+    return Ot;
+}
+
+var Mt;
+
+var Ft;
+
+function Nt() {
+    if (Ft) return Mt;
+    Ft = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = y;
+    const r = he();
+    const n = Ne();
+    const i = Re().pathExists;
+    function s(e, s) {
+        function o() {
+            r.writeFile(e, "", (e => {
+                if (e) return s(e);
+                s();
+            }));
+        }
+        r.stat(e, ((r, c) => {
+            if (!r && c.isFile()) return s();
+            const a = t.dirname(e);
+            i(a, ((e, t) => {
+                if (e) return s(e);
+                if (t) return o();
+                n.mkdirs(a, (e => {
+                    if (e) return s(e);
+                    o();
+                }));
+            }));
+        }));
+    }
+    function o(e) {
+        let i;
+        try {
+            i = r.statSync(e);
+        } catch (e) {}
+        if (i && i.isFile()) return;
+        const s = t.dirname(e);
+        if (!r.existsSync(s)) {
+            n.mkdirsSync(s);
+        }
+        r.writeFileSync(e, "");
+    }
+    Mt = {
+        createFile: e(s),
+        createFileSync: o
+    };
+    return Mt;
+}
+
+var Tt;
+
+var Lt;
+
+function Rt() {
+    if (Lt) return Tt;
+    Lt = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = y;
+    const r = he();
+    const n = Ne();
+    const i = Re().pathExists;
+    function s(e, s, o) {
+        function c(e, t) {
+            r.link(e, t, (e => {
+                if (e) return o(e);
+                o(null);
+            }));
+        }
+        i(s, ((a, f) => {
+            if (a) return o(a);
+            if (f) return o(null);
+            r.lstat(e, ((r, a) => {
+                if (r) {
+                    r.message = r.message.replace("lstat", "ensureLink");
+                    return o(r);
+                }
+                const f = t.dirname(s);
+                i(f, ((t, r) => {
+                    if (t) return o(t);
+                    if (r) return c(e, s);
+                    n.mkdirs(f, (t => {
+                        if (t) return o(t);
+                        c(e, s);
+                    }));
+                }));
+            }));
+        }));
+    }
+    function o(e, i, s) {
+        const o = r.existsSync(i);
+        if (o) return undefined;
+        try {
+            r.lstatSync(e);
+        } catch (e) {
+            e.message = e.message.replace("lstat", "ensureLink");
+            throw e;
+        }
+        const c = t.dirname(i);
+        const a = r.existsSync(c);
+        if (a) return r.linkSync(e, i);
+        n.mkdirsSync(c);
+        return r.linkSync(e, i);
+    }
+    Tt = {
+        createLink: e(s),
+        createLinkSync: o
+    };
+    return Tt;
+}
+
+var It;
+
+var zt;
+
+function At() {
+    if (zt) return It;
+    zt = 1;
+    "use strict";
+    const e = y;
+    const t = he();
+    const r = Re().pathExists;
+    function n(n, i, s) {
+        if (e.isAbsolute(n)) {
+            return t.lstat(n, ((e, t) => {
+                if (e) {
+                    e.message = e.message.replace("lstat", "ensureSymlink");
+                    return s(e);
+                }
+                return s(null, {
+                    toCwd: n,
+                    toDst: n
+                });
+            }));
+        } else {
+            const o = e.dirname(i);
+            const c = e.join(o, n);
+            return r(c, ((r, i) => {
+                if (r) return s(r);
+                if (i) {
+                    return s(null, {
+                        toCwd: c,
+                        toDst: n
+                    });
+                } else {
+                    return t.lstat(n, ((t, r) => {
+                        if (t) {
+                            t.message = t.message.replace("lstat", "ensureSymlink");
+                            return s(t);
+                        }
+                        return s(null, {
+                            toCwd: n,
+                            toDst: e.relative(o, n)
+                        });
+                    }));
+                }
+            }));
+        }
+    }
+    function i(r, n) {
+        let i;
+        if (e.isAbsolute(r)) {
+            i = t.existsSync(r);
+            if (!i) throw new Error("absolute srcpath does not exist");
+            return {
+                toCwd: r,
+                toDst: r
+            };
+        } else {
+            const s = e.dirname(n);
+            const o = e.join(s, r);
+            i = t.existsSync(o);
+            if (i) {
+                return {
+                    toCwd: o,
+                    toDst: r
+                };
+            } else {
+                i = t.existsSync(r);
+                if (!i) throw new Error("relative srcpath does not exist");
+                return {
+                    toCwd: r,
+                    toDst: e.relative(s, r)
+                };
+            }
+        }
+    }
+    It = {
+        symlinkPaths: n,
+        symlinkPathsSync: i
+    };
+    return It;
+}
+
+var Ct;
+
+var Kt;
+
+function qt() {
+    if (Kt) return Ct;
+    Kt = 1;
+    "use strict";
+    const e = he();
+    function t(t, r, n) {
+        n = typeof r === "function" ? r : n;
+        r = typeof r === "function" ? false : r;
+        if (r) return n(null, r);
+        e.lstat(t, ((e, t) => {
+            if (e) return n(null, "file");
+            r = t && t.isDirectory() ? "dir" : "file";
+            n(null, r);
+        }));
+    }
+    function r(t, r) {
+        let n;
+        if (r) return r;
+        try {
+            n = e.lstatSync(t);
+        } catch (e) {
+            return "file";
+        }
+        return n && n.isDirectory() ? "dir" : "file";
+    }
+    Ct = {
+        symlinkType: t,
+        symlinkTypeSync: r
+    };
+    return Ct;
+}
+
+var Jt;
+
+var Wt;
+
+function $t() {
+    if (Wt) return Jt;
+    Wt = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = y;
+    const r = he();
+    const n = Ne();
+    const i = n.mkdirs;
+    const s = n.mkdirsSync;
+    const o = At();
+    const c = o.symlinkPaths;
+    const a = o.symlinkPathsSync;
+    const f = qt();
+    const u = f.symlinkType;
+    const l = f.symlinkTypeSync;
+    const h = Re().pathExists;
+    function p(e, n, s, o) {
+        o = typeof s === "function" ? s : o;
+        s = typeof s === "function" ? false : s;
+        h(n, ((a, f) => {
+            if (a) return o(a);
+            if (f) return o(null);
+            c(e, n, ((c, a) => {
+                if (c) return o(c);
+                e = a.toDst;
+                u(a.toCwd, s, ((s, c) => {
+                    if (s) return o(s);
+                    const a = t.dirname(n);
+                    h(a, ((t, s) => {
+                        if (t) return o(t);
+                        if (s) return r.symlink(e, n, c, o);
+                        i(a, (t => {
+                            if (t) return o(t);
+                            r.symlink(e, n, c, o);
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }
+    function d(e, n, i, o) {
+        o = typeof i === "function" ? i : o;
+        i = typeof i === "function" ? false : i;
+        const c = r.existsSync(n);
+        if (c) return undefined;
+        const f = a(e, n);
+        e = f.toDst;
+        i = l(f.toCwd, i);
+        const u = t.dirname(n);
+        const h = r.existsSync(u);
+        if (h) return r.symlinkSync(e, n, i);
+        s(u);
+        return r.symlinkSync(e, n, i);
+    }
+    Jt = {
+        createSymlink: e(p),
+        createSymlinkSync: d
+    };
+    return Jt;
+}
+
+var Bt;
+
+var Gt;
+
+function Ut() {
+    if (Gt) return Bt;
+    Gt = 1;
+    "use strict";
+    const e = Nt();
+    const t = Rt();
+    const r = $t();
+    Bt = {
+        createFile: e.createFile,
+        createFileSync: e.createFileSync,
+        ensureFile: e.createFile,
+        ensureFileSync: e.createFileSync,
+        createLink: t.createLink,
+        createLinkSync: t.createLinkSync,
+        ensureLink: t.createLink,
+        ensureLinkSync: t.createLinkSync,
+        createSymlink: r.createSymlink,
+        createSymlinkSync: r.createSymlinkSync,
+        ensureSymlink: r.createSymlink,
+        ensureSymlinkSync: r.createSymlinkSync
+    };
+    return Bt;
+}
+
+var Yt;
+
+var Ht;
+
+function Vt() {
+    if (Ht) return Yt;
+    Ht = 1;
+    "use strict";
+    const e = ee().fromCallback;
+    const t = he();
+    const r = y;
+    const n = Ne();
+    const i = Re().pathExists;
+    function s(e, s, o, c) {
+        if (typeof o === "function") {
+            c = o;
+            o = "utf8";
+        }
+        const a = r.dirname(e);
+        i(a, ((r, i) => {
+            if (r) return c(r);
+            if (i) return t.writeFile(e, s, o, c);
+            n.mkdirs(a, (r => {
+                if (r) return c(r);
+                t.writeFile(e, s, o, c);
+            }));
+        }));
+    }
+    function o(e, i, s) {
+        const o = r.dirname(e);
+        if (t.existsSync(o)) {
+            return t.writeFileSync.apply(t, arguments);
+        }
+        n.mkdirsSync(o);
+        t.writeFileSync.apply(t, arguments);
+    }
+    Yt = {
+        outputFile: e(s),
+        outputFileSync: o
+    };
+    return Yt;
+}
+
+var Xt;
+
+var Qt;
+
+function Zt() {
+    if (Qt) return Xt;
+    Qt = 1;
+    "use strict";
+    const e = V();
+    const t = {};
+    e(t, ye());
+    e(t, qe());
+    e(t, Ze());
+    e(t, Ne());
+    e(t, st());
+    e(t, gt());
+    e(t, _t());
+    e(t, Pt());
+    e(t, jt());
+    e(t, Ut());
+    e(t, Vt());
+    e(t, Re());
+    Xt = t;
+    return Xt;
+}
+
+var er;
+
+var tr;
+
+function rr() {
+    if (tr) return er;
+    tr = 1;
+    "use strict";
+    var e = Object.defineProperty;
+    var t = Object.getOwnPropertyDescriptor;
+    var r = Object.getOwnPropertyNames;
+    var i = Object.prototype.hasOwnProperty;
+    var s = (t, r) => {
+        for (var n in r) e(t, n, {
+            get: r[n],
+            enumerable: true
+        });
+    };
+    var o = (n, s, o, c) => {
+        if (s && typeof s === "object" || typeof s === "function") {
+            for (let a of r(s)) if (!i.call(n, a) && a !== o) e(n, a, {
+                get: () => s[a],
+                enumerable: !(c = t(s, a)) || c.enumerable
+            });
+        }
+        return n;
+    };
+    var c = t => o(e({}, "__esModule", {
+        value: true
+    }), t);
+    var a = {};
+    s(a, {
+        defaultDeserialize: () => l,
+        defaultSerialize: () => u
+    });
+    er = c(a);
+    var f = n;
+    var u = e => {
+        if (e === void 0 || e === null) {
+            return "null";
+        }
+        if (typeof e === "string") {
+            return JSON.stringify(e.startsWith(":") ? ":" + e : e);
+        }
+        if (f.Buffer.isBuffer(e)) {
+            return JSON.stringify(":base64:" + e.toString("base64"));
+        }
+        if (e?.toJSON) {
+            e = e.toJSON();
+        }
+        if (typeof e === "object") {
+            let t = "";
+            const r = Array.isArray(e);
+            t = r ? "[" : "{";
+            let n = true;
+            for (const i in e) {
+                const s = typeof e[i] === "function" || !r && e[i] === void 0;
+                if (!Object.hasOwn(e, i) || s) {
+                    continue;
+                }
+                if (!n) {
+                    t += ",";
+                }
+                n = false;
+                if (r) {
+                    t += u(e[i]);
+                } else if (e[i] !== void 0) {
+                    t += u(i) + ":" + u(e[i]);
+                }
+            }
+            t += r ? "]" : "}";
+            return t;
+        }
+        return JSON.stringify(e);
+    };
+    var l = e => JSON.parse(e, ((e, t) => {
+        if (typeof t === "string") {
+            if (t.startsWith(":base64:")) {
+                return f.Buffer.from(t.slice(8), "base64");
+            }
+            return t.startsWith(":") ? t.slice(1) : t;
+        }
+        return t;
+    }));
+    0 && (module.exports = {
+        defaultDeserialize: l,
+        defaultSerialize: u
+    });
+    return er;
+}
+
+(function(e) {
+    "use strict";
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.Field = e.KeyvFile = e.defaultOpts = void 0;
+    e.makeField = f;
+    const t = c;
+    const n = t.__importStar(p);
+    const i = t.__importStar(Zt());
+    const s = t.__importDefault(r);
+    const o = rr();
+    e.defaultOpts = {
+        deserialize: o.defaultDeserialize,
+        dialect: "redis",
+        expiredCheckDelay: 24 * 3600 * 1e3,
+        filename: `${n.tmpdir()}/keyv-file/default.json`,
+        serialize: o.defaultSerialize,
+        writeDelay: 100,
+        checkFileLock: false
+    };
+    function a(e) {
+        return typeof e === "number";
+    }
+    class KeyvFile extends s.default {
+        constructor(t) {
+            super();
+            this.ttlSupport = true;
+            this.opts = Object.assign({}, e.defaultOpts, t);
+            if (this.opts.checkFileLock) {
+                this.acquireFileLock();
+            }
+            try {
+                const e = this.opts.deserialize(i.readFileSync(this.opts.filename, "utf8"));
+                if (!Array.isArray(e.cache)) {
+                    const t = e.cache;
+                    e.cache = [];
+                    for (const r in t) {
+                        if (t.hasOwnProperty(r)) {
+                            e.cache.push([ r, t[r] ]);
+                        }
+                    }
+                }
+                this._cache = new Map(e.cache);
+                this._lastExpire = e.lastExpire;
+            } catch (e) {
+                this._cache = new Map;
+                this._lastExpire = Date.now();
+            }
+        }
+        get _lockFile() {
+            return this.opts.filename + ".lock";
+        }
+        acquireFileLock() {
+            try {
+                let e = i.openSync(this._lockFile, "wx");
+                i.closeSync(e);
+                process.on("SIGINT", (() => {
+                    this.releaseFileLock();
+                    process.exit(0);
+                }));
+                process.on("exit", (() => {
+                    this.releaseFileLock();
+                }));
+            } catch (e) {
+                console.error(`[keyv-file] There is another process using this file`);
+                throw e;
+            }
+        }
+        releaseFileLock() {
+            try {
+                i.unlinkSync(this._lockFile);
+            } catch (e) {}
+        }
+        get(e) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                return Promise.resolve(this.getSync(e));
+            }));
+        }
+        getSync(e) {
+            try {
+                const t = this._cache.get(e);
+                if (!t) {
+                    return undefined;
+                } else if (this.isExpired(t)) {
+                    this.delete(e);
+                    return undefined;
+                } else {
+                    return t.value;
+                }
+            } catch (e) {}
+        }
+        getMany(e) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                const r = yield Promise.all(e.map((e => t.__awaiter(this, void 0, void 0, (function*() {
+                    const t = yield this.get(e);
+                    return t;
+                })))));
+                return r;
+            }));
+        }
+        set(e, r, n) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                if (n === 0) {
+                    n = undefined;
+                }
+                this._cache.set(e, {
+                    expire: a(n) ? Date.now() + n : undefined,
+                    value: r
+                });
+                return this.save();
+            }));
+        }
+        delete(e) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                const t = this._cache.delete(e);
+                yield this.save();
+                return t;
+            }));
+        }
+        deleteMany(e) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                const t = e.map((e => this.delete(e)));
+                const r = yield Promise.all(t);
+                return r.every((e => e));
+            }));
+        }
+        clear() {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                this._cache = new Map;
+                this._lastExpire = Date.now();
+                return this.save();
+            }));
+        }
+        has(e) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                const t = yield this.get(e);
+                return t !== undefined;
+            }));
+        }
+        isExpired(e) {
+            return a(e.expire) && e.expire <= Date.now();
+        }
+        clearExpire() {
+            const e = Date.now();
+            if (e - this._lastExpire <= this.opts.expiredCheckDelay) {
+                return;
+            }
+            for (const e of this._cache.keys()) {
+                const t = this._cache.get(e);
+                if (this.isExpired(t)) {
+                    this._cache.delete(e);
+                }
+            }
+            this._lastExpire = e;
+        }
+        saveToDisk() {
+            const e = [];
+            for (const [t, r] of this._cache) {
+                e.push([ t, r ]);
+            }
+            const t = this.opts.serialize({
+                cache: e,
+                lastExpire: this._lastExpire
+            });
+            return new Promise(((e, r) => {
+                i.outputFile(this.opts.filename, t, (t => {
+                    if (t) {
+                        r(t);
+                    } else {
+                        e();
+                    }
+                }));
+            }));
+        }
+        save() {
+            this.clearExpire();
+            if (this._savePromise) {
+                return this._savePromise;
+            }
+            this._savePromise = new Promise(((e, t) => {
+                setTimeout((() => {
+                    this.saveToDisk().then(e, t).finally((() => {
+                        this._savePromise = void 0;
+                    }));
+                }), this.opts.writeDelay);
+            }));
+            return this._savePromise;
+        }
+        disconnect() {
+            return Promise.resolve();
+        }
+        iterator(e) {
+            return t.__asyncGenerator(this, arguments, (function* r() {
+                for (const [r, n] of this._cache.entries()) {
+                    if (r === undefined) {
+                        continue;
+                    }
+                    if (!e || r.includes(e)) {
+                        yield yield t.__await([ r, n.value ]);
+                    }
+                }
+            }));
+        }
+    }
+    e.KeyvFile = KeyvFile;
+    e.default = KeyvFile;
+    class Field {
+        constructor(e, t, r) {
+            this.kv = e;
+            this.key = t;
+            this.defaults = r;
+        }
+        get() {
+            return t.__awaiter(this, arguments, void 0, (function*(e = this.defaults) {
+                var t;
+                return (t = yield this.kv.get(this.key)) !== null && t !== void 0 ? t : e;
+            }));
+        }
+        getSync(e = this.defaults) {
+            var t;
+            if ("getSync" in this.kv) {
+                return (t = this.kv.getSync(this.key)) !== null && t !== void 0 ? t : e;
+            }
+            throw new Error("kv does not support getSync");
+        }
+        set(e, t) {
+            return this.kv.set(this.key, e, t);
+        }
+        delete() {
+            return this.kv.delete(this.key);
+        }
+    }
+    e.Field = Field;
+    function f(e, t, r) {
+        return new Field(e, t, r);
+    }
+})(U);
+
+const nr = o(U);
+
+const ir = e => ({
+    class: Cacher,
+    options: e
+});
+
+class Cacher extends m {
+    async init() {
+        let e = undefined;
+        const t = this.options?.stores ? Array.isArray(this.options.stores) ? this.options.stores : [ this.options.stores ] : [];
+        for (const r of t) {
+            switch (r.type) {
+              case "file":
+                {
+                    if (!e) e = [];
+                    e.push(new F({
+                        store: new U.KeyvFile({
+                            filename: r.filename,
+                            expiredCheckDelay: r.expiredCheckDelay,
+                            writeDelay: r.writeDelay
+                        }),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+
+              case "redis":
+                {
+                    try {
+                        require.resolve("redis");
+                    } catch (e) {
+                        throw new Error('Node-Redis package is required for this driver. Run "npm install redis".');
+                    }
+                    if (!e) e = [];
+                    const t = (await import("./Package.65.mjs")).default;
+                    e.push(new F({
+                        store: new t({
+                            username: r.username,
+                            password: r.password,
+                            database: r.database,
+                            socket: {
+                                host: r.host,
+                                port: r.port,
+                                tls: r.tls,
+                                keepAlive: r.keepAlive,
+                                reconnectStrategy: r.reconnect ? 10 : false
+                            }
+                        }, {
+                            namespace: r.namespace,
+                            keyPrefixSeparator: r.keyPrefixSeparator,
+                            clearBatchSize: r.clearBatchSize,
+                            useUnlink: r.useUnlink,
+                            noNamespaceAffectsAll: r.noNamespaceAffectsAll,
+                            connectionTimeout: r.connectTimeout,
+                            throwOnConnectError: r.throwOnConnectError
+                        }),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+
+              case "memcache":
+                {
+                    try {
+                        require.resolve("memjs");
+                    } catch (e) {
+                        throw new Error('MemJS package is required for this driver. Run "npm install memjs".');
+                    }
+                    if (!e) e = [];
+                    const t = (await import("./Package.66.mjs")).KeyvMemcache;
+                    const n = new w;
+                    n.host = r.host;
+                    n.port = r.port;
+                    n.username = r.username;
+                    n.password = r.password;
+                    e.push(new F({
+                        store: new t(n.toString()),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+
+              case "mongo":
+                {
+                    try {
+                        require.resolve("mongodb");
+                    } catch (e) {
+                        throw new Error('MongoDB package is required for this driver. Run "npm install mongodb".');
+                    }
+                    if (!e) e = [];
+                    const t = (await import("./Package.67.mjs")).KeyvMongo;
+                    const n = new w;
+                    n.protocol = "mongodb";
+                    n.host = r.host;
+                    n.port = r.port;
+                    n.username = r.username;
+                    n.password = r.password;
+                    e.push(new F({
+                        store: new t(n.toString(), {
+                            db: r.database,
+                            namespace: r.namespace,
+                            collection: r.collection
+                        }),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+
+              case "sqlite":
+                {
+                    try {
+                        require.resolve("sqlite3");
+                    } catch (e) {
+                        throw new Error('SQLite3 package is required for this driver. Run "npm install sqlite3".');
+                    }
+                    if (!e) e = [];
+                    const t = (await import("./Package.68.mjs")).KeyvSqlite;
+                    const n = new w;
+                    n.protocol = "sqlite";
+                    n.pathname = r.database;
+                    e.push(new F({
+                        store: new t({
+                            uri: n.toString(),
+                            table: r.table,
+                            busyTimeout: r.busyTimeout
+                        }),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+
+              case "postgres":
+                {
+                    try {
+                        require.resolve("pg");
+                    } catch (e) {
+                        throw new Error('Node-Postgres package is required for this driver. Run "npm install pg".');
+                    }
+                    if (!e) e = [];
+                    const t = (await import("./Package.69.mjs")).KeyvPostgres;
+                    const n = new w;
+                    n.protocol = "postgresql";
+                    n.host = r.host;
+                    n.port = r.port;
+                    n.username = r.username;
+                    n.password = r.password;
+                    n.pathname = r.database;
+                    e.push(new F({
+                        store: new t({
+                            uri: n.toString(),
+                            table: r.table,
+                            schema: r.schema,
+                            max: r.maxPoolSize
+                        }),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+
+              case "mysql":
+                {
+                    try {
+                        require.resolve("mysql2");
+                    } catch (e) {
+                        throw new Error('MySQL2 package is required for this driver. Run "npm install mysql2".');
+                    }
+                    if (!e) e = [];
+                    const t = (await import("./Package.610.mjs")).KeyvMysql;
+                    e.push(new F({
+                        store: new t({
+                            host: r.host,
+                            port: r.port,
+                            user: r.username,
+                            password: r.password,
+                            database: r.database,
+                            table: r.table
+                        }),
+                        namespace: r.namespace
+                    }));
+                }
+                break;
+            }
+        }
+        this.cache = G({
+            ...this.options,
+            stores: e
+        });
+        this.cache.on("set", (e => this.emit("set", e)));
+        this.cache.on("del", (e => this.emit("del", e)));
+        this.cache.on("clear", (e => this.emit("clear", e)));
+        this.cache.on("refresh", (e => this.emit("refresh", e)));
+    }
+    async destroy() {
+        await this.cache.disconnect();
+    }
+    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 S(await this.cache.get(e));
+    }
+    async multipleGet(e) {
+        return await this.cache.mget(e);
+    }
+    async ttl(e) {
+        const t = await this.cache.ttl(e);
+        if (t === undefined) return -1;
+        return t;
+    }
+    async del(e) {
+        return await this.cache.del(e);
+    }
+    async multipleDel(e) {
+        return await this.cache.mdel(e);
+    }
+    async clear() {
+        return await this.cache.clear();
+    }
+    on(e, t) {
+        return super.on(e, t);
+    }
+}
+
+e([ v(d.optional()), t("design:type", d) ], Cacher.prototype, "options", void 0);
+
+export { ir as B, Cacher as C, M as K, k as d, F as i };