lakutata 2.0.34 → 2.0.36

package/src/components/cacher/adapters/CreateFileCacheAdapter.cjs

@@ -0,0 +1,3094 @@
+"use strict";
+
+Object.defineProperty(exports, Symbol.toStringTag, {
+    value: "Module"
+});
+
+const e = require("../../../../vendor/Package.65.cjs");
+
+const t = require("../../../../vendor/Package.5.cjs");
+
+const n = require("../../../../vendor/Package.13.cjs");
+
+require("../../../../vendor/Package.8.cjs");
+
+require("../../../../vendor/Package.19.cjs");
+
+const r = require("constants");
+
+const i = require("stream");
+
+require("../../../../vendor/Package.10.cjs");
+
+require("../../../../vendor/Package.17.cjs");
+
+const o = require("fs");
+
+const c = require("util");
+
+const s = require("assert");
+
+const f = require("os");
+
+const u = require("path");
+
+require("../../../../vendor/Package.14.cjs");
+
+const a = require("buffer");
+
+const l = require("events");
+
+require("../../../../vendor/Package.1.cjs");
+
+const d = e => e && e.__esModule ? e : {
+    default: e
+};
+
+const y = d(r);
+
+const p = d(i);
+
+const h = d(o);
+
+const m = d(c);
+
+const v = d(s);
+
+const S = d(f);
+
+const w = d(u);
+
+const E = d(a);
+
+const k = d(l);
+
+var b = {};
+
+var g;
+
+var O;
+
+function _() {
+    if (O) return g;
+    O = 1;
+    "use strict";
+    function e() {
+        const e = [].slice.call(arguments).filter((e => e));
+        const t = e.shift();
+        e.forEach((e => {
+            Object.keys(e).forEach((n => {
+                t[n] = e[n];
+            }));
+        }));
+        return t;
+    }
+    g = e;
+    return g;
+}
+
+var F = {};
+
+var x = {};
+
+var D;
+
+function P() {
+    if (D) return x;
+    D = 1;
+    "use strict";
+    x.fromCallback = function(e) {
+        return Object.defineProperty((function() {
+            if (typeof arguments[arguments.length - 1] === "function") e.apply(this, arguments); else {
+                return new Promise(((t, n) => {
+                    arguments[arguments.length] = (e, r) => {
+                        if (e) return n(e);
+                        t(r);
+                    };
+                    arguments.length++;
+                    e.apply(this, arguments);
+                }));
+            }
+        }), "name", {
+            value: e.name
+        });
+    };
+    x.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 x;
+}
+
+var N;
+
+var j;
+
+function T() {
+    if (j) return N;
+    j = 1;
+    var e = y.default;
+    var t = process.cwd;
+    var n = null;
+    var r = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+        if (!n) n = t.call(process);
+        return n;
+    };
+    try {
+        process.cwd();
+    } catch (e) {}
+    if (typeof process.chdir === "function") {
+        var i = process.chdir;
+        process.chdir = function(e) {
+            n = null;
+            i.call(process, e);
+        };
+        if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, i);
+    }
+    N = o;
+    function o(t) {
+        if (e.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+            n(t);
+        }
+        if (!t.lutimes) {
+            i(t);
+        }
+        t.chown = s(t.chown);
+        t.fchown = s(t.fchown);
+        t.lchown = s(t.lchown);
+        t.chmod = o(t.chmod);
+        t.fchmod = o(t.fchmod);
+        t.lchmod = o(t.lchmod);
+        t.chownSync = f(t.chownSync);
+        t.fchownSync = f(t.fchownSync);
+        t.lchownSync = f(t.lchownSync);
+        t.chmodSync = c(t.chmodSync);
+        t.fchmodSync = c(t.fchmodSync);
+        t.lchmodSync = c(t.lchmodSync);
+        t.stat = u(t.stat);
+        t.fstat = u(t.fstat);
+        t.lstat = u(t.lstat);
+        t.statSync = a(t.statSync);
+        t.fstatSync = a(t.fstatSync);
+        t.lstatSync = a(t.lstatSync);
+        if (t.chmod && !t.lchmod) {
+            t.lchmod = function(e, t, n) {
+                if (n) process.nextTick(n);
+            };
+            t.lchmodSync = function() {};
+        }
+        if (t.chown && !t.lchown) {
+            t.lchown = function(e, t, n, r) {
+                if (r) process.nextTick(r);
+            };
+            t.lchownSync = function() {};
+        }
+        if (r === "win32") {
+            t.rename = typeof t.rename !== "function" ? t.rename : function(e) {
+                function n(n, r, i) {
+                    var o = Date.now();
+                    var c = 0;
+                    e(n, r, (function s(f) {
+                        if (f && (f.code === "EACCES" || f.code === "EPERM" || f.code === "EBUSY") && Date.now() - o < 6e4) {
+                            setTimeout((function() {
+                                t.stat(r, (function(t, o) {
+                                    if (t && t.code === "ENOENT") e(n, r, s); else i(f);
+                                }));
+                            }), c);
+                            if (c < 100) c += 10;
+                            return;
+                        }
+                        if (i) i(f);
+                    }));
+                }
+                if (Object.setPrototypeOf) Object.setPrototypeOf(n, e);
+                return n;
+            }(t.rename);
+        }
+        t.read = typeof t.read !== "function" ? t.read : function(e) {
+            function n(n, r, i, o, c, s) {
+                var f;
+                if (s && typeof s === "function") {
+                    var u = 0;
+                    f = function(a, l, d) {
+                        if (a && a.code === "EAGAIN" && u < 10) {
+                            u++;
+                            return e.call(t, n, r, i, o, c, f);
+                        }
+                        s.apply(this, arguments);
+                    };
+                }
+                return e.call(t, n, r, i, o, c, f);
+            }
+            if (Object.setPrototypeOf) Object.setPrototypeOf(n, e);
+            return n;
+        }(t.read);
+        t.readSync = typeof t.readSync !== "function" ? t.readSync : function(e) {
+            return function(n, r, i, o, c) {
+                var s = 0;
+                while (true) {
+                    try {
+                        return e.call(t, n, r, i, o, c);
+                    } catch (e) {
+                        if (e.code === "EAGAIN" && s < 10) {
+                            s++;
+                            continue;
+                        }
+                        throw e;
+                    }
+                }
+            };
+        }(t.readSync);
+        function n(t) {
+            t.lchmod = function(n, r, i) {
+                t.open(n, e.O_WRONLY | e.O_SYMLINK, r, (function(e, n) {
+                    if (e) {
+                        if (i) i(e);
+                        return;
+                    }
+                    t.fchmod(n, r, (function(e) {
+                        t.close(n, (function(t) {
+                            if (i) i(e || t);
+                        }));
+                    }));
+                }));
+            };
+            t.lchmodSync = function(n, r) {
+                var i = t.openSync(n, e.O_WRONLY | e.O_SYMLINK, r);
+                var o = true;
+                var c;
+                try {
+                    c = t.fchmodSync(i, r);
+                    o = false;
+                } finally {
+                    if (o) {
+                        try {
+                            t.closeSync(i);
+                        } catch (e) {}
+                    } else {
+                        t.closeSync(i);
+                    }
+                }
+                return c;
+            };
+        }
+        function i(t) {
+            if (e.hasOwnProperty("O_SYMLINK") && t.futimes) {
+                t.lutimes = function(n, r, i, o) {
+                    t.open(n, e.O_SYMLINK, (function(e, n) {
+                        if (e) {
+                            if (o) o(e);
+                            return;
+                        }
+                        t.futimes(n, r, i, (function(e) {
+                            t.close(n, (function(t) {
+                                if (o) o(e || t);
+                            }));
+                        }));
+                    }));
+                };
+                t.lutimesSync = function(n, r, i) {
+                    var o = t.openSync(n, e.O_SYMLINK);
+                    var c;
+                    var s = true;
+                    try {
+                        c = t.futimesSync(o, r, i);
+                        s = false;
+                    } finally {
+                        if (s) {
+                            try {
+                                t.closeSync(o);
+                            } catch (e) {}
+                        } else {
+                            t.closeSync(o);
+                        }
+                    }
+                    return c;
+                };
+            } else if (t.futimes) {
+                t.lutimes = function(e, t, n, r) {
+                    if (r) process.nextTick(r);
+                };
+                t.lutimesSync = function() {};
+            }
+        }
+        function o(e) {
+            if (!e) return e;
+            return function(n, r, i) {
+                return e.call(t, n, r, (function(e) {
+                    if (l(e)) e = null;
+                    if (i) i.apply(this, arguments);
+                }));
+            };
+        }
+        function c(e) {
+            if (!e) return e;
+            return function(n, r) {
+                try {
+                    return e.call(t, n, r);
+                } catch (e) {
+                    if (!l(e)) throw e;
+                }
+            };
+        }
+        function s(e) {
+            if (!e) return e;
+            return function(n, r, i, o) {
+                return e.call(t, n, r, i, (function(e) {
+                    if (l(e)) e = null;
+                    if (o) o.apply(this, arguments);
+                }));
+            };
+        }
+        function f(e) {
+            if (!e) return e;
+            return function(n, r, i) {
+                try {
+                    return e.call(t, n, r, i);
+                } catch (e) {
+                    if (!l(e)) throw e;
+                }
+            };
+        }
+        function u(e) {
+            if (!e) return e;
+            return function(n, r, i) {
+                if (typeof r === "function") {
+                    i = r;
+                    r = null;
+                }
+                function o(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 r ? e.call(t, n, r, o) : e.call(t, n, o);
+            };
+        }
+        function a(e) {
+            if (!e) return e;
+            return function(n, r) {
+                var i = r ? e.call(t, n, r) : e.call(t, n);
+                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 N;
+}
+
+var M;
+
+var L;
+
+function R() {
+    if (L) return M;
+    L = 1;
+    var e = p.default.Stream;
+    M = t;
+    function t(t) {
+        return {
+            ReadStream: n,
+            WriteStream: r
+        };
+        function n(r, i) {
+            if (!(this instanceof n)) return new n(r, i);
+            e.call(this);
+            var o = this;
+            this.path = r;
+            this.fd = null;
+            this.readable = true;
+            this.paused = false;
+            this.flags = "r";
+            this.mode = 438;
+            this.bufferSize = 64 * 1024;
+            i = i || {};
+            var c = Object.keys(i);
+            for (var s = 0, f = c.length; s < f; s++) {
+                var u = c[s];
+                this[u] = i[u];
+            }
+            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() {
+                    o._read();
+                }));
+                return;
+            }
+            t.open(this.path, this.flags, this.mode, (function(e, t) {
+                if (e) {
+                    o.emit("error", e);
+                    o.readable = false;
+                    return;
+                }
+                o.fd = t;
+                o.emit("open", t);
+                o._read();
+            }));
+        }
+        function r(n, i) {
+            if (!(this instanceof r)) return new r(n, i);
+            e.call(this);
+            this.path = n;
+            this.fd = null;
+            this.writable = true;
+            this.flags = "w";
+            this.encoding = "binary";
+            this.mode = 438;
+            this.bytesWritten = 0;
+            i = i || {};
+            var o = Object.keys(i);
+            for (var c = 0, s = o.length; c < s; c++) {
+                var f = o[c];
+                this[f] = i[f];
+            }
+            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 M;
+}
+
+var I;
+
+var C;
+
+function q() {
+    if (C) return I;
+    C = 1;
+    "use strict";
+    I = 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 n = {
+            __proto__: e(t)
+        }; else var n = Object.create(null);
+        Object.getOwnPropertyNames(t).forEach((function(e) {
+            Object.defineProperty(n, e, Object.getOwnPropertyDescriptor(t, e));
+        }));
+        return n;
+    }
+    return I;
+}
+
+var J;
+
+var W;
+
+function A() {
+    if (W) return J;
+    W = 1;
+    var e = h.default;
+    var n = T();
+    var r = R();
+    var i = q();
+    var o = m.default;
+    var c;
+    var s;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+        c = Symbol.for("graceful-fs.queue");
+        s = Symbol.for("graceful-fs.previous");
+    } else {
+        c = "___graceful-fs.queue";
+        s = "___graceful-fs.previous";
+    }
+    function f() {}
+    function u(e, t) {
+        Object.defineProperty(e, c, {
+            get: function() {
+                return t;
+            }
+        });
+    }
+    var a = f;
+    if (o.debuglog) a = o.debuglog("gfs4"); else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) a = function() {
+        var e = o.format.apply(o, arguments);
+        e = "GFS4: " + e.split(/\n/).join("\nGFS4: ");
+        console.error(e);
+    };
+    if (!e[c]) {
+        var l = t.commonjsGlobal[c] || [];
+        u(e, l);
+        e.close = function(t) {
+            function n(n, r) {
+                return t.call(e, n, (function(e) {
+                    if (!e) {
+                        S();
+                    }
+                    if (typeof r === "function") r.apply(this, arguments);
+                }));
+            }
+            Object.defineProperty(n, s, {
+                value: t
+            });
+            return n;
+        }(e.close);
+        e.closeSync = function(t) {
+            function n(n) {
+                t.apply(e, arguments);
+                S();
+            }
+            Object.defineProperty(n, s, {
+                value: t
+            });
+            return n;
+        }(e.closeSync);
+        if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+            process.on("exit", (function() {
+                a(e[c]);
+                v.default.equal(e[c].length, 0);
+            }));
+        }
+    }
+    if (!t.commonjsGlobal[c]) {
+        u(t.commonjsGlobal, e[c]);
+    }
+    J = d(i(e));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !e.__patched) {
+        J = d(e);
+        e.__patched = true;
+    }
+    function d(e) {
+        n(e);
+        e.gracefulify = d;
+        e.createReadStream = _;
+        e.createWriteStream = F;
+        var t = e.readFile;
+        e.readFile = i;
+        function i(e, n, r) {
+            if (typeof n === "function") r = n, n = null;
+            return i(e, n, r);
+            function i(e, n, r, o) {
+                return t(e, n, (function(t) {
+                    if (t && (t.code === "EMFILE" || t.code === "ENFILE")) y([ i, [ e, n, r ], t, o || Date.now(), Date.now() ]); else {
+                        if (typeof r === "function") r.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var o = e.writeFile;
+        e.writeFile = c;
+        function c(e, t, n, r) {
+            if (typeof n === "function") r = n, n = null;
+            return i(e, t, n, r);
+            function i(e, t, n, r, c) {
+                return o(e, t, n, (function(o) {
+                    if (o && (o.code === "EMFILE" || o.code === "ENFILE")) y([ i, [ e, t, n, r ], o, c || Date.now(), Date.now() ]); else {
+                        if (typeof r === "function") r.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var s = e.appendFile;
+        if (s) e.appendFile = f;
+        function f(e, t, n, r) {
+            if (typeof n === "function") r = n, n = null;
+            return i(e, t, n, r);
+            function i(e, t, n, r, o) {
+                return s(e, t, n, (function(c) {
+                    if (c && (c.code === "EMFILE" || c.code === "ENFILE")) y([ i, [ e, t, n, r ], c, o || Date.now(), Date.now() ]); else {
+                        if (typeof r === "function") r.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var u = e.copyFile;
+        if (u) e.copyFile = a;
+        function a(e, t, n, r) {
+            if (typeof n === "function") {
+                r = n;
+                n = 0;
+            }
+            return i(e, t, n, r);
+            function i(e, t, n, r, o) {
+                return u(e, t, n, (function(c) {
+                    if (c && (c.code === "EMFILE" || c.code === "ENFILE")) y([ i, [ e, t, n, r ], c, o || Date.now(), Date.now() ]); else {
+                        if (typeof r === "function") r.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        var l = e.readdir;
+        e.readdir = h;
+        var p = /^v[0-5]\./;
+        function h(e, t, n) {
+            if (typeof t === "function") n = t, t = null;
+            var r = p.test(process.version) ? function e(t, n, r, o) {
+                return l(t, i(t, n, r, o));
+            } : function e(t, n, r, o) {
+                return l(t, n, i(t, n, r, o));
+            };
+            return r(e, t, n);
+            function i(e, t, n, i) {
+                return function(o, c) {
+                    if (o && (o.code === "EMFILE" || o.code === "ENFILE")) y([ r, [ e, t, n ], o, i || Date.now(), Date.now() ]); else {
+                        if (c && c.sort) c.sort();
+                        if (typeof n === "function") n.call(this, o, c);
+                    }
+                };
+            }
+        }
+        if (process.version.substr(0, 4) === "v0.8") {
+            var m = r(e);
+            k = m.ReadStream;
+            g = m.WriteStream;
+        }
+        var v = e.ReadStream;
+        if (v) {
+            k.prototype = Object.create(v.prototype);
+            k.prototype.open = b;
+        }
+        var S = e.WriteStream;
+        if (S) {
+            g.prototype = Object.create(S.prototype);
+            g.prototype.open = O;
+        }
+        Object.defineProperty(e, "ReadStream", {
+            get: function() {
+                return k;
+            },
+            set: function(e) {
+                k = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(e, "WriteStream", {
+            get: function() {
+                return g;
+            },
+            set: function(e) {
+                g = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        var w = k;
+        Object.defineProperty(e, "FileReadStream", {
+            get: function() {
+                return w;
+            },
+            set: function(e) {
+                w = e;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        var E = g;
+        Object.defineProperty(e, "FileWriteStream", {
+            get: function() {
+                return E;
+            },
+            set: function(e) {
+                E = 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 b() {
+            var e = this;
+            D(e.path, e.flags, e.mode, (function(t, n) {
+                if (t) {
+                    if (e.autoClose) e.destroy();
+                    e.emit("error", t);
+                } else {
+                    e.fd = n;
+                    e.emit("open", n);
+                    e.read();
+                }
+            }));
+        }
+        function g(e, t) {
+            if (this instanceof g) return S.apply(this, arguments), this; else return g.apply(Object.create(g.prototype), arguments);
+        }
+        function O() {
+            var e = this;
+            D(e.path, e.flags, e.mode, (function(t, n) {
+                if (t) {
+                    e.destroy();
+                    e.emit("error", t);
+                } else {
+                    e.fd = n;
+                    e.emit("open", n);
+                }
+            }));
+        }
+        function _(t, n) {
+            return new e.ReadStream(t, n);
+        }
+        function F(t, n) {
+            return new e.WriteStream(t, n);
+        }
+        var x = e.open;
+        e.open = D;
+        function D(e, t, n, r) {
+            if (typeof n === "function") r = n, n = null;
+            return i(e, t, n, r);
+            function i(e, t, n, r, o) {
+                return x(e, t, n, (function(c, s) {
+                    if (c && (c.code === "EMFILE" || c.code === "ENFILE")) y([ i, [ e, t, n, r ], c, o || Date.now(), Date.now() ]); else {
+                        if (typeof r === "function") r.apply(this, arguments);
+                    }
+                }));
+            }
+        }
+        return e;
+    }
+    function y(t) {
+        a("ENQUEUE", t[0].name, t[1]);
+        e[c].push(t);
+        w();
+    }
+    var p;
+    function S() {
+        var t = Date.now();
+        for (var n = 0; n < e[c].length; ++n) {
+            if (e[c][n].length > 2) {
+                e[c][n][3] = t;
+                e[c][n][4] = t;
+            }
+        }
+        w();
+    }
+    function w() {
+        clearTimeout(p);
+        p = undefined;
+        if (e[c].length === 0) return;
+        var t = e[c].shift();
+        var n = t[0];
+        var r = t[1];
+        var i = t[2];
+        var o = t[3];
+        var s = t[4];
+        if (o === undefined) {
+            a("RETRY", n.name, r);
+            n.apply(null, r);
+        } else if (Date.now() - o >= 6e4) {
+            a("TIMEOUT", n.name, r);
+            var f = r.pop();
+            if (typeof f === "function") f.call(null, i);
+        } else {
+            var u = Date.now() - s;
+            var l = Math.max(s - o, 1);
+            var d = Math.min(l * 1.2, 100);
+            if (u >= d) {
+                a("RETRY", n.name, r);
+                n.apply(null, r.concat([ o ]));
+            } else {
+                e[c].push(t);
+            }
+        }
+        if (p === undefined) {
+            p = setTimeout(w, 0);
+        }
+    }
+    return J;
+}
+
+var B;
+
+function Y() {
+    if (B) return F;
+    B = 1;
+    (function(e) {
+        const t = P().fromCallback;
+        const n = A();
+        const r = [ "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 n[e] === "function"));
+        Object.keys(n).forEach((t => {
+            e[t] = n[t];
+        }));
+        r.forEach((r => {
+            e[r] = t(n[r]);
+        }));
+        e.exists = function(e, t) {
+            if (typeof t === "function") {
+                return n.exists(e, t);
+            }
+            return new Promise((t => n.exists(e, t)));
+        };
+        e.read = function(e, t, r, i, o, c) {
+            if (typeof c === "function") {
+                return n.read(e, t, r, i, o, c);
+            }
+            return new Promise(((c, s) => {
+                n.read(e, t, r, i, o, ((e, t, n) => {
+                    if (e) return s(e);
+                    c({
+                        bytesRead: t,
+                        buffer: n
+                    });
+                }));
+            }));
+        };
+        e.write = function(e, t, r, i, o, c) {
+            if (typeof arguments[arguments.length - 1] === "function") {
+                return n.write(e, t, r, i, o, c);
+            }
+            if (typeof t === "string") {
+                return new Promise(((o, c) => {
+                    n.write(e, t, r, i, ((e, t, n) => {
+                        if (e) return c(e);
+                        o({
+                            bytesWritten: t,
+                            buffer: n
+                        });
+                    }));
+                }));
+            }
+            return new Promise(((c, s) => {
+                n.write(e, t, r, i, o, ((e, t, n) => {
+                    if (e) return s(e);
+                    c({
+                        bytesWritten: t,
+                        buffer: n
+                    });
+                }));
+            }));
+        };
+    })(F);
+    return F;
+}
+
+var $;
+
+var U;
+
+function G() {
+    if (U) return $;
+    U = 1;
+    "use strict";
+    const e = A();
+    const t = S.default;
+    const n = w.default;
+    function r() {
+        let r = n.join("millis-test-sync" + Date.now().toString() + Math.random().toString().slice(2));
+        r = n.join(t.tmpdir(), r);
+        const i = new Date(1435410243862);
+        e.writeFileSync(r, "https://github.com/jprichardson/node-fs-extra/pull/141");
+        const o = e.openSync(r, "r+");
+        e.futimesSync(o, i, i);
+        e.closeSync(o);
+        return e.statSync(r).mtime > 1435410243e3;
+    }
+    function i(r) {
+        let i = n.join("millis-test" + Date.now().toString() + Math.random().toString().slice(2));
+        i = n.join(t.tmpdir(), i);
+        const o = new Date(1435410243862);
+        e.writeFile(i, "https://github.com/jprichardson/node-fs-extra/pull/141", (t => {
+            if (t) return r(t);
+            e.open(i, "r+", ((t, n) => {
+                if (t) return r(t);
+                e.futimes(n, o, o, (t => {
+                    if (t) return r(t);
+                    e.close(n, (t => {
+                        if (t) return r(t);
+                        e.stat(i, ((e, t) => {
+                            if (e) return r(e);
+                            r(null, t.mtime > 1435410243e3);
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }
+    function o(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 c(t, n, r, i) {
+        e.open(t, "r+", ((t, o) => {
+            if (t) return i(t);
+            e.futimes(o, n, r, (t => {
+                e.close(o, (e => {
+                    if (i) i(t || e);
+                }));
+            }));
+        }));
+    }
+    $ = {
+        hasMillisRes: i,
+        hasMillisResSync: r,
+        timeRemoveMillis: o,
+        utimesMillis: c
+    };
+    return $;
+}
+
+var z;
+
+var K;
+
+function X() {
+    if (K) return z;
+    K = 1;
+    var e = A();
+    var t = w.default;
+    var n = G();
+    function r(r, i, o, c) {
+        if (!c) {
+            c = o;
+            o = {};
+        }
+        var s = process.cwd();
+        var f = t.resolve(s, r);
+        var u = t.resolve(s, i);
+        var a = o.filter;
+        var l = o.transform;
+        var d = o.overwrite;
+        if (d === undefined) d = o.clobber;
+        if (d === undefined) d = true;
+        var y = o.errorOnExist;
+        var p = o.dereference;
+        var h = o.preserveTimestamps === true;
+        var m = 0;
+        var v = 0;
+        var S = 0;
+        var w = false;
+        E(f);
+        function E(e) {
+            m++;
+            if (a) {
+                if (a instanceof RegExp) {
+                    console.warn("Warning: fs-extra: Passing a RegExp filter is deprecated, use a function");
+                    if (!a.test(e)) {
+                        return M(true);
+                    }
+                } else if (typeof a === "function") {
+                    if (!a(e, i)) {
+                        return M(true);
+                    }
+                }
+            }
+            return k(e);
+        }
+        function k(t) {
+            var n = p ? e.stat : e.lstat;
+            S++;
+            n(t, (function(e, n) {
+                if (e) return T(e);
+                var r = {
+                    name: t,
+                    mode: n.mode,
+                    mtime: n.mtime,
+                    atime: n.atime,
+                    stats: n
+                };
+                if (n.isDirectory()) {
+                    return _(r);
+                } else if (n.isFile() || n.isCharacterDevice() || n.isBlockDevice()) {
+                    return b(r);
+                } else if (n.isSymbolicLink()) {
+                    return D(t);
+                }
+            }));
+        }
+        function b(e) {
+            var t = e.name.replace(f, u.replace("$", "$$$$"));
+            j(t, (function(n) {
+                if (n) {
+                    g(e, t);
+                } else {
+                    if (d) {
+                        O(t, (function() {
+                            g(e, t);
+                        }));
+                    } else if (y) {
+                        T(new Error(t + " already exists"));
+                    } else {
+                        M();
+                    }
+                }
+            }));
+        }
+        function g(t, r) {
+            var i = e.createReadStream(t.name);
+            var o = e.createWriteStream(r, {
+                mode: t.mode
+            });
+            i.on("error", T);
+            o.on("error", T);
+            if (l) {
+                l(i, o, t);
+            } else {
+                o.on("open", (function() {
+                    i.pipe(o);
+                }));
+            }
+            o.once("close", (function() {
+                e.chmod(r, t.mode, (function(e) {
+                    if (e) return T(e);
+                    if (h) {
+                        n.utimesMillis(r, t.atime, t.mtime, (function(e) {
+                            if (e) return T(e);
+                            return M();
+                        }));
+                    } else {
+                        M();
+                    }
+                }));
+            }));
+        }
+        function O(t, n) {
+            e.unlink(t, (function(e) {
+                if (e) return T(e);
+                return n();
+            }));
+        }
+        function _(e) {
+            var t = e.name.replace(f, u.replace("$", "$$$$"));
+            j(t, (function(n) {
+                if (n) {
+                    return F(e, t);
+                }
+                x(e.name);
+            }));
+        }
+        function F(t, n) {
+            e.mkdir(n, t.mode, (function(r) {
+                if (r) return T(r);
+                e.chmod(n, t.mode, (function(e) {
+                    if (e) return T(e);
+                    x(t.name);
+                }));
+            }));
+        }
+        function x(n) {
+            e.readdir(n, (function(e, r) {
+                if (e) return T(e);
+                r.forEach((function(e) {
+                    E(t.join(n, e));
+                }));
+                return M();
+            }));
+        }
+        function D(t) {
+            var n = t.replace(f, u);
+            e.readlink(t, (function(e, t) {
+                if (e) return T(e);
+                P(t, n);
+            }));
+        }
+        function P(n, r) {
+            if (p) {
+                n = t.resolve(s, n);
+            }
+            j(r, (function(i) {
+                if (i) {
+                    return N(n, r);
+                }
+                e.readlink(r, (function(e, i) {
+                    if (e) return T(e);
+                    if (p) {
+                        i = t.resolve(s, i);
+                    }
+                    if (i === n) {
+                        return M();
+                    }
+                    return O(r, (function() {
+                        N(n, r);
+                    }));
+                }));
+            }));
+        }
+        function N(t, n) {
+            e.symlink(t, n, (function(e) {
+                if (e) return T(e);
+                return M();
+            }));
+        }
+        function j(t, n) {
+            e.lstat(t, (function(e) {
+                if (e) {
+                    if (e.code === "ENOENT") return n(true);
+                    return n(false);
+                }
+                return n(false);
+            }));
+        }
+        function T(e) {
+            if (!w && c !== undefined) {
+                w = true;
+                return c(e);
+            }
+        }
+        function M(e) {
+            if (!e) S--;
+            v++;
+            if (m === v && S === 0) {
+                if (c !== undefined) {
+                    return c(null);
+                }
+            }
+        }
+    }
+    z = r;
+    return z;
+}
+
+var V;
+
+var H;
+
+function Q() {
+    if (H) return V;
+    H = 1;
+    "use strict";
+    const e = w.default;
+    function t(t) {
+        t = e.normalize(e.resolve(t)).split(e.sep);
+        if (t.length > 0) return t[0];
+        return null;
+    }
+    const n = /[<>:"|?*]/;
+    function r(e) {
+        const r = t(e);
+        e = e.replace(r, "");
+        return n.test(e);
+    }
+    V = {
+        getRootPath: t,
+        invalidWin32Path: r
+    };
+    return V;
+}
+
+var Z;
+
+var ee;
+
+function te() {
+    if (ee) return Z;
+    ee = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = Q().invalidWin32Path;
+    const r = parseInt("0777", 8);
+    function i(o, c, s, f) {
+        if (typeof c === "function") {
+            s = c;
+            c = {};
+        } else if (!c || typeof c !== "object") {
+            c = {
+                mode: c
+            };
+        }
+        if (process.platform === "win32" && n(o)) {
+            const e = new Error(o + " contains invalid WIN32 path characters.");
+            e.code = "EINVAL";
+            return s(e);
+        }
+        let u = c.mode;
+        const a = c.fs || e;
+        if (u === undefined) {
+            u = r & ~process.umask();
+        }
+        if (!f) f = null;
+        s = s || function() {};
+        o = t.resolve(o);
+        a.mkdir(o, u, (e => {
+            if (!e) {
+                f = f || o;
+                return s(null, f);
+            }
+            switch (e.code) {
+              case "ENOENT":
+                if (t.dirname(o) === o) return s(e);
+                i(t.dirname(o), c, ((e, t) => {
+                    if (e) s(e, t); else i(o, c, s, t);
+                }));
+                break;
+
+              default:
+                a.stat(o, ((t, n) => {
+                    if (t || !n.isDirectory()) s(e, f); else s(null, f);
+                }));
+                break;
+            }
+        }));
+    }
+    Z = i;
+    return Z;
+}
+
+var ne;
+
+var re;
+
+function ie() {
+    if (re) return ne;
+    re = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = Q().invalidWin32Path;
+    const r = parseInt("0777", 8);
+    function i(o, c, s) {
+        if (!c || typeof c !== "object") {
+            c = {
+                mode: c
+            };
+        }
+        let f = c.mode;
+        const u = c.fs || e;
+        if (process.platform === "win32" && n(o)) {
+            const e = new Error(o + " contains invalid WIN32 path characters.");
+            e.code = "EINVAL";
+            throw e;
+        }
+        if (f === undefined) {
+            f = r & ~process.umask();
+        }
+        if (!s) s = null;
+        o = t.resolve(o);
+        try {
+            u.mkdirSync(o, f);
+            s = s || o;
+        } catch (e) {
+            switch (e.code) {
+              case "ENOENT":
+                if (t.dirname(o) === o) throw e;
+                s = i(t.dirname(o), c, s);
+                i(o, c, s);
+                break;
+
+              default:
+                let n;
+                try {
+                    n = u.statSync(o);
+                } catch (t) {
+                    throw e;
+                }
+                if (!n.isDirectory()) throw e;
+                break;
+            }
+        }
+        return s;
+    }
+    ne = i;
+    return ne;
+}
+
+var oe;
+
+var ce;
+
+function se() {
+    if (ce) return oe;
+    ce = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = e(te());
+    const n = ie();
+    oe = {
+        mkdirs: t,
+        mkdirsSync: n,
+        mkdirp: t,
+        mkdirpSync: n,
+        ensureDir: t,
+        ensureDirSync: n
+    };
+    return oe;
+}
+
+var fe;
+
+var ue;
+
+function ae() {
+    if (ue) return fe;
+    ue = 1;
+    "use strict";
+    const e = P().fromPromise;
+    const t = Y();
+    function n(e) {
+        return t.access(e).then((() => true)).catch((() => false));
+    }
+    fe = {
+        pathExists: e(n),
+        pathExistsSync: t.existsSync
+    };
+    return fe;
+}
+
+var le;
+
+var de;
+
+function ye() {
+    if (de) return le;
+    de = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = X();
+    const r = se();
+    const i = ae().pathExists;
+    function o(o, c, s, f) {
+        if (typeof s === "function" && !f) {
+            f = s;
+            s = {};
+        } else if (typeof s === "function" || s instanceof RegExp) {
+            s = {
+                filter: s
+            };
+        }
+        f = f || function() {};
+        s = s || {};
+        if (s.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 u = process.cwd();
+        const a = t.resolve(u, o);
+        const l = t.resolve(u, c);
+        if (a === l) return f(new Error("Source and destination must not be the same."));
+        e.lstat(o, ((e, u) => {
+            if (e) return f(e);
+            let a = null;
+            if (u.isDirectory()) {
+                const e = c.split(t.sep);
+                e.pop();
+                a = e.join(t.sep);
+            } else {
+                a = t.dirname(c);
+            }
+            i(a, ((e, t) => {
+                if (e) return f(e);
+                if (t) return n(o, c, s, f);
+                r.mkdirs(a, (e => {
+                    if (e) return f(e);
+                    n(o, c, s, f);
+                }));
+            }));
+        }));
+    }
+    le = o;
+    return le;
+}
+
+var pe;
+
+var he;
+
+function me() {
+    if (he) return pe;
+    he = 1;
+    const e = P().fromCallback;
+    pe = {
+        copy: e(ye())
+    };
+    return pe;
+}
+
+var ve;
+
+var Se;
+
+function we() {
+    if (Se) return ve;
+    Se = 1;
+    ve = function(e) {
+        if (typeof Buffer.allocUnsafe === "function") {
+            try {
+                return Buffer.allocUnsafe(e);
+            } catch (t) {
+                return new Buffer(e);
+            }
+        }
+        return new Buffer(e);
+    };
+    return ve;
+}
+
+var Ee;
+
+var ke;
+
+function be() {
+    if (ke) return Ee;
+    ke = 1;
+    "use strict";
+    const e = A();
+    const t = 64 * 1024;
+    const n = we()(t);
+    function r(r, i, o) {
+        const c = o.overwrite;
+        const s = o.errorOnExist;
+        const f = o.preserveTimestamps;
+        if (e.existsSync(i)) {
+            if (c) {
+                e.unlinkSync(i);
+            } else if (s) {
+                throw new Error(`${i} already exists`);
+            } else return;
+        }
+        const u = e.openSync(r, "r");
+        const a = e.fstatSync(u);
+        const l = e.openSync(i, "w", a.mode);
+        let d = 1;
+        let y = 0;
+        while (d > 0) {
+            d = e.readSync(u, n, 0, t, y);
+            e.writeSync(l, n, 0, d);
+            y += d;
+        }
+        if (f) {
+            e.futimesSync(l, a.atime, a.mtime);
+        }
+        e.closeSync(u);
+        e.closeSync(l);
+    }
+    Ee = r;
+    return Ee;
+}
+
+var ge;
+
+var Oe;
+
+function _e() {
+    if (Oe) return ge;
+    Oe = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = be();
+    const r = se();
+    function i(o, c, s) {
+        if (typeof s === "function" || s instanceof RegExp) {
+            s = {
+                filter: s
+            };
+        }
+        s = s || {};
+        s.recursive = !!s.recursive;
+        s.clobber = "clobber" in s ? !!s.clobber : true;
+        s.overwrite = "overwrite" in s ? !!s.overwrite : s.clobber;
+        s.dereference = "dereference" in s ? !!s.dereference : false;
+        s.preserveTimestamps = "preserveTimestamps" in s ? !!s.preserveTimestamps : false;
+        s.filter = s.filter || function() {
+            return true;
+        };
+        if (s.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 = s.recursive && !s.dereference ? e.lstatSync(o) : e.statSync(o);
+        const u = t.dirname(c);
+        const a = e.existsSync(u);
+        let l = false;
+        if (s.filter instanceof RegExp) {
+            console.warn("Warning: fs-extra: Passing a RegExp filter is deprecated, use a function");
+            l = s.filter.test(o);
+        } else if (typeof s.filter === "function") l = s.filter(o, c);
+        if (f.isFile() && l) {
+            if (!a) r.mkdirsSync(u);
+            n(o, c, {
+                overwrite: s.overwrite,
+                errorOnExist: s.errorOnExist,
+                preserveTimestamps: s.preserveTimestamps
+            });
+        } else if (f.isDirectory() && l) {
+            if (!e.existsSync(c)) r.mkdirsSync(c);
+            const n = e.readdirSync(o);
+            n.forEach((e => {
+                const n = s;
+                n.recursive = true;
+                i(t.join(o, e), t.join(c, e), n);
+            }));
+        } else if (s.recursive && f.isSymbolicLink() && l) {
+            const t = e.readlinkSync(o);
+            e.symlinkSync(t, c);
+        }
+    }
+    ge = i;
+    return ge;
+}
+
+var Fe;
+
+var xe;
+
+function De() {
+    if (xe) return Fe;
+    xe = 1;
+    Fe = {
+        copySync: _e()
+    };
+    return Fe;
+}
+
+var Pe;
+
+var Ne;
+
+function je() {
+    if (Ne) return Pe;
+    Ne = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = v.default;
+    const r = process.platform === "win32";
+    function i(t) {
+        const n = [ "unlink", "chmod", "stat", "lstat", "rmdir", "readdir" ];
+        n.forEach((n => {
+            t[n] = t[n] || e[n];
+            n = n + "Sync";
+            t[n] = t[n] || e[n];
+        }));
+        t.maxBusyTries = t.maxBusyTries || 3;
+    }
+    function o(e, t, r) {
+        let o = 0;
+        if (typeof t === "function") {
+            r = t;
+            t = {};
+        }
+        n(e, "rimraf: missing path");
+        n.equal(typeof e, "string", "rimraf: path should be a string");
+        n.equal(typeof r, "function", "rimraf: callback function required");
+        n(t, "rimraf: invalid options argument provided");
+        n.equal(typeof t, "object", "rimraf: options should be object");
+        i(t);
+        c(e, t, (function n(i) {
+            if (i) {
+                if ((i.code === "EBUSY" || i.code === "ENOTEMPTY" || i.code === "EPERM") && o < t.maxBusyTries) {
+                    o++;
+                    let r = o * 100;
+                    return setTimeout((() => c(e, t, n)), r);
+                }
+                if (i.code === "ENOENT") i = null;
+            }
+            r(i);
+        }));
+    }
+    function c(e, t, i) {
+        n(e);
+        n(t);
+        n(typeof i === "function");
+        t.lstat(e, ((n, o) => {
+            if (n && n.code === "ENOENT") {
+                return i(null);
+            }
+            if (n && n.code === "EPERM" && r) {
+                return s(e, t, n, i);
+            }
+            if (o && o.isDirectory()) {
+                return u(e, t, n, i);
+            }
+            t.unlink(e, (n => {
+                if (n) {
+                    if (n.code === "ENOENT") {
+                        return i(null);
+                    }
+                    if (n.code === "EPERM") {
+                        return r ? s(e, t, n, i) : u(e, t, n, i);
+                    }
+                    if (n.code === "EISDIR") {
+                        return u(e, t, n, i);
+                    }
+                }
+                return i(n);
+            }));
+        }));
+    }
+    function s(e, t, r, i) {
+        n(e);
+        n(t);
+        n(typeof i === "function");
+        if (r) {
+            n(r instanceof Error);
+        }
+        t.chmod(e, 438, (n => {
+            if (n) {
+                i(n.code === "ENOENT" ? null : r);
+            } else {
+                t.stat(e, ((n, o) => {
+                    if (n) {
+                        i(n.code === "ENOENT" ? null : r);
+                    } else if (o.isDirectory()) {
+                        u(e, t, r, i);
+                    } else {
+                        t.unlink(e, i);
+                    }
+                }));
+            }
+        }));
+    }
+    function f(e, t, r) {
+        let i;
+        n(e);
+        n(t);
+        if (r) {
+            n(r instanceof Error);
+        }
+        try {
+            t.chmodSync(e, 438);
+        } catch (e) {
+            if (e.code === "ENOENT") {
+                return;
+            } else {
+                throw r;
+            }
+        }
+        try {
+            i = t.statSync(e);
+        } catch (e) {
+            if (e.code === "ENOENT") {
+                return;
+            } else {
+                throw r;
+            }
+        }
+        if (i.isDirectory()) {
+            d(e, t, r);
+        } else {
+            t.unlinkSync(e);
+        }
+    }
+    function u(e, t, r, i) {
+        n(e);
+        n(t);
+        if (r) {
+            n(r instanceof Error);
+        }
+        n(typeof i === "function");
+        t.rmdir(e, (n => {
+            if (n && (n.code === "ENOTEMPTY" || n.code === "EEXIST" || n.code === "EPERM")) {
+                a(e, t, i);
+            } else if (n && n.code === "ENOTDIR") {
+                i(r);
+            } else {
+                i(n);
+            }
+        }));
+    }
+    function a(e, r, i) {
+        n(e);
+        n(r);
+        n(typeof i === "function");
+        r.readdir(e, ((n, c) => {
+            if (n) return i(n);
+            let s = c.length;
+            let f;
+            if (s === 0) return r.rmdir(e, i);
+            c.forEach((n => {
+                o(t.join(e, n), r, (t => {
+                    if (f) {
+                        return;
+                    }
+                    if (t) return i(f = t);
+                    if (--s === 0) {
+                        r.rmdir(e, i);
+                    }
+                }));
+            }));
+        }));
+    }
+    function l(e, t) {
+        let o;
+        t = t || {};
+        i(t);
+        n(e, "rimraf: missing path");
+        n.equal(typeof e, "string", "rimraf: path should be a string");
+        n(t, "rimraf: missing options");
+        n.equal(typeof t, "object", "rimraf: options should be object");
+        try {
+            o = t.lstatSync(e);
+        } catch (n) {
+            if (n.code === "ENOENT") {
+                return;
+            }
+            if (n.code === "EPERM" && r) {
+                f(e, t, n);
+            }
+        }
+        try {
+            if (o && o.isDirectory()) {
+                d(e, t, null);
+            } else {
+                t.unlinkSync(e);
+            }
+        } catch (n) {
+            if (n.code === "ENOENT") {
+                return;
+            } else if (n.code === "EPERM") {
+                return r ? f(e, t, n) : d(e, t, n);
+            } else if (n.code !== "EISDIR") {
+                throw n;
+            }
+            d(e, t, n);
+        }
+    }
+    function d(e, t, r) {
+        n(e);
+        n(t);
+        if (r) {
+            n(r instanceof Error);
+        }
+        try {
+            t.rmdirSync(e);
+        } catch (n) {
+            if (n.code === "ENOTDIR") {
+                throw r;
+            } else if (n.code === "ENOTEMPTY" || n.code === "EEXIST" || n.code === "EPERM") {
+                y(e, t);
+            } else if (n.code !== "ENOENT") {
+                throw n;
+            }
+        }
+    }
+    function y(e, i) {
+        n(e);
+        n(i);
+        i.readdirSync(e).forEach((n => l(t.join(e, n), i)));
+        const o = r ? 100 : 1;
+        let c = 0;
+        do {
+            let t = true;
+            try {
+                const n = i.rmdirSync(e, i);
+                t = false;
+                return n;
+            } finally {
+                if (++c < o && t) continue;
+            }
+        } while (true);
+    }
+    Pe = o;
+    o.sync = l;
+    return Pe;
+}
+
+var Te;
+
+var Me;
+
+function Le() {
+    if (Me) return Te;
+    Me = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = je();
+    Te = {
+        remove: e(t),
+        removeSync: t.sync
+    };
+    return Te;
+}
+
+var Re;
+
+var Ie;
+
+function Ce() {
+    if (Ie) return Re;
+    Ie = 1;
+    var e;
+    try {
+        e = A();
+    } catch (t) {
+        e = h.default;
+    }
+    function t(t, n, r) {
+        if (r == null) {
+            r = n;
+            n = {};
+        }
+        if (typeof n === "string") {
+            n = {
+                encoding: n
+            };
+        }
+        n = n || {};
+        var i = n.fs || e;
+        var o = true;
+        if ("throws" in n) {
+            o = n.throws;
+        }
+        i.readFile(t, n, (function(e, i) {
+            if (e) return r(e);
+            i = c(i);
+            var s;
+            try {
+                s = JSON.parse(i, n ? n.reviver : null);
+            } catch (e) {
+                if (o) {
+                    e.message = t + ": " + e.message;
+                    return r(e);
+                } else {
+                    return r(null, null);
+                }
+            }
+            r(null, s);
+        }));
+    }
+    function n(t, n) {
+        n = n || {};
+        if (typeof n === "string") {
+            n = {
+                encoding: n
+            };
+        }
+        var r = n.fs || e;
+        var i = true;
+        if ("throws" in n) {
+            i = n.throws;
+        }
+        try {
+            var o = r.readFileSync(t, n);
+            o = c(o);
+            return JSON.parse(o, n.reviver);
+        } catch (e) {
+            if (i) {
+                e.message = t + ": " + e.message;
+                throw e;
+            } else {
+                return null;
+            }
+        }
+    }
+    function r(e, t) {
+        var n;
+        var r = "\n";
+        if (typeof t === "object" && t !== null) {
+            if (t.spaces) {
+                n = t.spaces;
+            }
+            if (t.EOL) {
+                r = t.EOL;
+            }
+        }
+        var i = JSON.stringify(e, t ? t.replacer : null, n);
+        return i.replace(/\n/g, r) + r;
+    }
+    function i(t, n, i, o) {
+        if (o == null) {
+            o = i;
+            i = {};
+        }
+        i = i || {};
+        var c = i.fs || e;
+        var s = "";
+        try {
+            s = r(n, i);
+        } catch (e) {
+            if (o) o(e, null);
+            return;
+        }
+        c.writeFile(t, s, i, o);
+    }
+    function o(t, n, i) {
+        i = i || {};
+        var o = i.fs || e;
+        var c = r(n, i);
+        return o.writeFileSync(t, c, i);
+    }
+    function c(e) {
+        if (Buffer.isBuffer(e)) e = e.toString("utf8");
+        e = e.replace(/^\uFEFF/, "");
+        return e;
+    }
+    var s = {
+        readFile: t,
+        readFileSync: n,
+        writeFile: i,
+        writeFileSync: o
+    };
+    Re = s;
+    return Re;
+}
+
+var qe;
+
+var Je;
+
+function We() {
+    if (Je) return qe;
+    Je = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = Ce();
+    qe = {
+        readJson: e(t.readFile),
+        readJsonSync: t.readFileSync,
+        writeJson: e(t.writeFile),
+        writeJsonSync: t.writeFileSync
+    };
+    return qe;
+}
+
+var Ae;
+
+var Be;
+
+function Ye() {
+    if (Be) return Ae;
+    Be = 1;
+    "use strict";
+    const e = w.default;
+    const t = se();
+    const n = ae().pathExists;
+    const r = We();
+    function i(i, o, c, s) {
+        if (typeof c === "function") {
+            s = c;
+            c = {};
+        }
+        const f = e.dirname(i);
+        n(f, ((e, n) => {
+            if (e) return s(e);
+            if (n) return r.writeJson(i, o, c, s);
+            t.mkdirs(f, (e => {
+                if (e) return s(e);
+                r.writeJson(i, o, c, s);
+            }));
+        }));
+    }
+    Ae = i;
+    return Ae;
+}
+
+var $e;
+
+var Ue;
+
+function Ge() {
+    if (Ue) return $e;
+    Ue = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = se();
+    const r = We();
+    function i(i, o, c) {
+        const s = t.dirname(i);
+        if (!e.existsSync(s)) {
+            n.mkdirsSync(s);
+        }
+        r.writeJsonSync(i, o, c);
+    }
+    $e = i;
+    return $e;
+}
+
+var ze;
+
+var Ke;
+
+function Xe() {
+    if (Ke) return ze;
+    Ke = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = We();
+    t.outputJson = e(Ye());
+    t.outputJsonSync = Ge();
+    t.outputJSON = t.outputJson;
+    t.outputJSONSync = t.outputJsonSync;
+    t.writeJSON = t.writeJson;
+    t.writeJSONSync = t.writeJsonSync;
+    t.readJSON = t.readJson;
+    t.readJSONSync = t.readJsonSync;
+    ze = t;
+    return ze;
+}
+
+var Ve;
+
+var He;
+
+function Qe() {
+    if (He) return Ve;
+    He = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = A();
+    const n = X();
+    const r = w.default;
+    const i = Le().remove;
+    const o = se().mkdirs;
+    function c(e, n, f, u) {
+        if (typeof f === "function") {
+            u = f;
+            f = {};
+        }
+        const l = f.overwrite || f.clobber || false;
+        a(e, n, ((t, i) => {
+            if (t) return u(t);
+            if (i) return u(new Error(`Cannot move '${e}' to a subdirectory of itself, '${n}'.`));
+            o(r.dirname(n), (e => {
+                if (e) return u(e);
+                d();
+            }));
+        }));
+        function d() {
+            if (r.resolve(e) === r.resolve(n)) {
+                t.access(e, u);
+            } else if (l) {
+                t.rename(e, n, (t => {
+                    if (!t) return u();
+                    if (t.code === "ENOTEMPTY" || t.code === "EEXIST") {
+                        i(n, (t => {
+                            if (t) return u(t);
+                            f.overwrite = false;
+                            c(e, n, f, u);
+                        }));
+                        return;
+                    }
+                    if (t.code === "EPERM") {
+                        setTimeout((() => {
+                            i(n, (t => {
+                                if (t) return u(t);
+                                f.overwrite = false;
+                                c(e, n, f, u);
+                            }));
+                        }), 200);
+                        return;
+                    }
+                    if (t.code !== "EXDEV") return u(t);
+                    s(e, n, l, u);
+                }));
+            } else {
+                t.link(e, n, (r => {
+                    if (r) {
+                        if (r.code === "EXDEV" || r.code === "EISDIR" || r.code === "EPERM" || r.code === "ENOTSUP") {
+                            return s(e, n, l, u);
+                        }
+                        return u(r);
+                    }
+                    return t.unlink(e, u);
+                }));
+            }
+        }
+    }
+    function s(e, n, r, i) {
+        t.stat(e, ((t, o) => {
+            if (t) return i(t);
+            if (o.isDirectory()) {
+                u(e, n, r, i);
+            } else {
+                f(e, n, r, i);
+            }
+        }));
+    }
+    function f(e, n, r, i) {
+        const o = r ? "w" : "wx";
+        const c = t.createReadStream(e);
+        const s = t.createWriteStream(n, {
+            flags: o
+        });
+        c.on("error", (o => {
+            c.destroy();
+            s.destroy();
+            s.removeListener("close", f);
+            t.unlink(n, (() => {
+                if (o.code === "EISDIR" || o.code === "EPERM") {
+                    u(e, n, r, i);
+                } else {
+                    i(o);
+                }
+            }));
+        }));
+        s.on("error", (e => {
+            c.destroy();
+            s.destroy();
+            s.removeListener("close", f);
+            i(e);
+        }));
+        s.once("close", f);
+        c.pipe(s);
+        function f() {
+            t.unlink(e, i);
+        }
+    }
+    function u(e, t, r, o) {
+        const c = {
+            overwrite: false
+        };
+        if (r) {
+            i(t, (e => {
+                if (e) return o(e);
+                s();
+            }));
+        } else {
+            s();
+        }
+        function s() {
+            n(e, t, c, (t => {
+                if (t) return o(t);
+                i(e, o);
+            }));
+        }
+    }
+    function a(e, n, i) {
+        t.stat(e, ((t, o) => {
+            if (t) return i(t);
+            if (o.isDirectory()) {
+                const t = n.split(r.dirname(e) + r.sep)[1];
+                if (t) {
+                    const o = t.split(r.sep)[0];
+                    if (o) return i(null, e !== n && n.indexOf(e) > -1 && o === r.basename(e));
+                    return i(null, false);
+                }
+                return i(null, false);
+            }
+            return i(null, false);
+        }));
+    }
+    Ve = {
+        move: e(c)
+    };
+    return Ve;
+}
+
+var Ze;
+
+var et;
+
+function tt() {
+    if (et) return Ze;
+    et = 1;
+    "use strict";
+    const e = A();
+    const t = w.default;
+    const n = De().copySync;
+    const r = Le().removeSync;
+    const i = se().mkdirsSync;
+    const o = we();
+    function c(n, o, f) {
+        f = f || {};
+        const u = f.overwrite || f.clobber || false;
+        n = t.resolve(n);
+        o = t.resolve(o);
+        if (n === o) return e.accessSync(n);
+        if (a(n, o)) throw new Error(`Cannot move '${n}' into itself '${o}'.`);
+        i(t.dirname(o));
+        l();
+        function l() {
+            if (u) {
+                try {
+                    return e.renameSync(n, o);
+                } catch (e) {
+                    if (e.code === "ENOTEMPTY" || e.code === "EEXIST" || e.code === "EPERM") {
+                        r(o);
+                        f.overwrite = false;
+                        return c(n, o, f);
+                    }
+                    if (e.code !== "EXDEV") throw e;
+                    return s(n, o, u);
+                }
+            } else {
+                try {
+                    e.linkSync(n, o);
+                    return e.unlinkSync(n);
+                } catch (e) {
+                    if (e.code === "EXDEV" || e.code === "EISDIR" || e.code === "EPERM" || e.code === "ENOTSUP") {
+                        return s(n, o, u);
+                    }
+                    throw e;
+                }
+            }
+        }
+    }
+    function s(t, n, r) {
+        const i = e.statSync(t);
+        if (i.isDirectory()) {
+            return u(t, n, r);
+        } else {
+            return f(t, n, r);
+        }
+    }
+    function f(t, n, r) {
+        const i = 64 * 1024;
+        const c = o(i);
+        const s = r ? "w" : "wx";
+        const f = e.openSync(t, "r");
+        const u = e.fstatSync(f);
+        const a = e.openSync(n, s, u.mode);
+        let l = 1;
+        let d = 0;
+        while (l > 0) {
+            l = e.readSync(f, c, 0, i, d);
+            e.writeSync(a, c, 0, l);
+            d += l;
+        }
+        e.closeSync(f);
+        e.closeSync(a);
+        return e.unlinkSync(t);
+    }
+    function u(e, t, i) {
+        const o = {
+            overwrite: false
+        };
+        if (i) {
+            r(t);
+            c();
+        } else {
+            c();
+        }
+        function c() {
+            n(e, t, o);
+            return r(e);
+        }
+    }
+    function a(n, r) {
+        try {
+            return e.statSync(n).isDirectory() && n !== r && r.indexOf(n) > -1 && r.split(t.dirname(n) + t.sep)[1].split(t.sep)[0] === t.basename(n);
+        } catch (e) {
+            return false;
+        }
+    }
+    Ze = {
+        moveSync: c
+    };
+    return Ze;
+}
+
+var nt;
+
+var rt;
+
+function it() {
+    if (rt) return nt;
+    rt = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = h.default;
+    const n = w.default;
+    const r = se();
+    const i = Le();
+    const o = e((function e(o, c) {
+        c = c || function() {};
+        t.readdir(o, ((e, t) => {
+            if (e) return r.mkdirs(o, c);
+            t = t.map((e => n.join(o, e)));
+            s();
+            function s() {
+                const e = t.pop();
+                if (!e) return c();
+                i.remove(e, (e => {
+                    if (e) return c(e);
+                    s();
+                }));
+            }
+        }));
+    }));
+    function c(e) {
+        let o;
+        try {
+            o = t.readdirSync(e);
+        } catch (t) {
+            return r.mkdirsSync(e);
+        }
+        o.forEach((t => {
+            t = n.join(e, t);
+            i.removeSync(t);
+        }));
+    }
+    nt = {
+        emptyDirSync: c,
+        emptydirSync: c,
+        emptyDir: o,
+        emptydir: o
+    };
+    return nt;
+}
+
+var ot;
+
+var ct;
+
+function st() {
+    if (ct) return ot;
+    ct = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = w.default;
+    const n = A();
+    const r = se();
+    const i = ae().pathExists;
+    function o(e, o) {
+        function c() {
+            n.writeFile(e, "", (e => {
+                if (e) return o(e);
+                o();
+            }));
+        }
+        n.stat(e, ((n, s) => {
+            if (!n && s.isFile()) return o();
+            const f = t.dirname(e);
+            i(f, ((e, t) => {
+                if (e) return o(e);
+                if (t) return c();
+                r.mkdirs(f, (e => {
+                    if (e) return o(e);
+                    c();
+                }));
+            }));
+        }));
+    }
+    function c(e) {
+        let i;
+        try {
+            i = n.statSync(e);
+        } catch (e) {}
+        if (i && i.isFile()) return;
+        const o = t.dirname(e);
+        if (!n.existsSync(o)) {
+            r.mkdirsSync(o);
+        }
+        n.writeFileSync(e, "");
+    }
+    ot = {
+        createFile: e(o),
+        createFileSync: c
+    };
+    return ot;
+}
+
+var ft;
+
+var ut;
+
+function at() {
+    if (ut) return ft;
+    ut = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = w.default;
+    const n = A();
+    const r = se();
+    const i = ae().pathExists;
+    function o(e, o, c) {
+        function s(e, t) {
+            n.link(e, t, (e => {
+                if (e) return c(e);
+                c(null);
+            }));
+        }
+        i(o, ((f, u) => {
+            if (f) return c(f);
+            if (u) return c(null);
+            n.lstat(e, ((n, f) => {
+                if (n) {
+                    n.message = n.message.replace("lstat", "ensureLink");
+                    return c(n);
+                }
+                const u = t.dirname(o);
+                i(u, ((t, n) => {
+                    if (t) return c(t);
+                    if (n) return s(e, o);
+                    r.mkdirs(u, (t => {
+                        if (t) return c(t);
+                        s(e, o);
+                    }));
+                }));
+            }));
+        }));
+    }
+    function c(e, i, o) {
+        const c = n.existsSync(i);
+        if (c) return undefined;
+        try {
+            n.lstatSync(e);
+        } catch (e) {
+            e.message = e.message.replace("lstat", "ensureLink");
+            throw e;
+        }
+        const s = t.dirname(i);
+        const f = n.existsSync(s);
+        if (f) return n.linkSync(e, i);
+        r.mkdirsSync(s);
+        return n.linkSync(e, i);
+    }
+    ft = {
+        createLink: e(o),
+        createLinkSync: c
+    };
+    return ft;
+}
+
+var lt;
+
+var dt;
+
+function yt() {
+    if (dt) return lt;
+    dt = 1;
+    "use strict";
+    const e = w.default;
+    const t = A();
+    const n = ae().pathExists;
+    function r(r, i, o) {
+        if (e.isAbsolute(r)) {
+            return t.lstat(r, ((e, t) => {
+                if (e) {
+                    e.message = e.message.replace("lstat", "ensureSymlink");
+                    return o(e);
+                }
+                return o(null, {
+                    toCwd: r,
+                    toDst: r
+                });
+            }));
+        } else {
+            const c = e.dirname(i);
+            const s = e.join(c, r);
+            return n(s, ((n, i) => {
+                if (n) return o(n);
+                if (i) {
+                    return o(null, {
+                        toCwd: s,
+                        toDst: r
+                    });
+                } else {
+                    return t.lstat(r, ((t, n) => {
+                        if (t) {
+                            t.message = t.message.replace("lstat", "ensureSymlink");
+                            return o(t);
+                        }
+                        return o(null, {
+                            toCwd: r,
+                            toDst: e.relative(c, r)
+                        });
+                    }));
+                }
+            }));
+        }
+    }
+    function i(n, r) {
+        let i;
+        if (e.isAbsolute(n)) {
+            i = t.existsSync(n);
+            if (!i) throw new Error("absolute srcpath does not exist");
+            return {
+                toCwd: n,
+                toDst: n
+            };
+        } else {
+            const o = e.dirname(r);
+            const c = e.join(o, n);
+            i = t.existsSync(c);
+            if (i) {
+                return {
+                    toCwd: c,
+                    toDst: n
+                };
+            } else {
+                i = t.existsSync(n);
+                if (!i) throw new Error("relative srcpath does not exist");
+                return {
+                    toCwd: n,
+                    toDst: e.relative(o, n)
+                };
+            }
+        }
+    }
+    lt = {
+        symlinkPaths: r,
+        symlinkPathsSync: i
+    };
+    return lt;
+}
+
+var pt;
+
+var ht;
+
+function mt() {
+    if (ht) return pt;
+    ht = 1;
+    "use strict";
+    const e = A();
+    function t(t, n, r) {
+        r = typeof n === "function" ? n : r;
+        n = typeof n === "function" ? false : n;
+        if (n) return r(null, n);
+        e.lstat(t, ((e, t) => {
+            if (e) return r(null, "file");
+            n = t && t.isDirectory() ? "dir" : "file";
+            r(null, n);
+        }));
+    }
+    function n(t, n) {
+        let r;
+        if (n) return n;
+        try {
+            r = e.lstatSync(t);
+        } catch (e) {
+            return "file";
+        }
+        return r && r.isDirectory() ? "dir" : "file";
+    }
+    pt = {
+        symlinkType: t,
+        symlinkTypeSync: n
+    };
+    return pt;
+}
+
+var vt;
+
+var St;
+
+function wt() {
+    if (St) return vt;
+    St = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = w.default;
+    const n = A();
+    const r = se();
+    const i = r.mkdirs;
+    const o = r.mkdirsSync;
+    const c = yt();
+    const s = c.symlinkPaths;
+    const f = c.symlinkPathsSync;
+    const u = mt();
+    const a = u.symlinkType;
+    const l = u.symlinkTypeSync;
+    const d = ae().pathExists;
+    function y(e, r, o, c) {
+        c = typeof o === "function" ? o : c;
+        o = typeof o === "function" ? false : o;
+        d(r, ((f, u) => {
+            if (f) return c(f);
+            if (u) return c(null);
+            s(e, r, ((s, f) => {
+                if (s) return c(s);
+                e = f.toDst;
+                a(f.toCwd, o, ((o, s) => {
+                    if (o) return c(o);
+                    const f = t.dirname(r);
+                    d(f, ((t, o) => {
+                        if (t) return c(t);
+                        if (o) return n.symlink(e, r, s, c);
+                        i(f, (t => {
+                            if (t) return c(t);
+                            n.symlink(e, r, s, c);
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }
+    function p(e, r, i, c) {
+        c = typeof i === "function" ? i : c;
+        i = typeof i === "function" ? false : i;
+        const s = n.existsSync(r);
+        if (s) return undefined;
+        const u = f(e, r);
+        e = u.toDst;
+        i = l(u.toCwd, i);
+        const a = t.dirname(r);
+        const d = n.existsSync(a);
+        if (d) return n.symlinkSync(e, r, i);
+        o(a);
+        return n.symlinkSync(e, r, i);
+    }
+    vt = {
+        createSymlink: e(y),
+        createSymlinkSync: p
+    };
+    return vt;
+}
+
+var Et;
+
+var kt;
+
+function bt() {
+    if (kt) return Et;
+    kt = 1;
+    "use strict";
+    const e = st();
+    const t = at();
+    const n = wt();
+    Et = {
+        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: n.createSymlink,
+        createSymlinkSync: n.createSymlinkSync,
+        ensureSymlink: n.createSymlink,
+        ensureSymlinkSync: n.createSymlinkSync
+    };
+    return Et;
+}
+
+var gt;
+
+var Ot;
+
+function _t() {
+    if (Ot) return gt;
+    Ot = 1;
+    "use strict";
+    const e = P().fromCallback;
+    const t = A();
+    const n = w.default;
+    const r = se();
+    const i = ae().pathExists;
+    function o(e, o, c, s) {
+        if (typeof c === "function") {
+            s = c;
+            c = "utf8";
+        }
+        const f = n.dirname(e);
+        i(f, ((n, i) => {
+            if (n) return s(n);
+            if (i) return t.writeFile(e, o, c, s);
+            r.mkdirs(f, (n => {
+                if (n) return s(n);
+                t.writeFile(e, o, c, s);
+            }));
+        }));
+    }
+    function c(e, i, o) {
+        const c = n.dirname(e);
+        if (t.existsSync(c)) {
+            return t.writeFileSync.apply(t, arguments);
+        }
+        r.mkdirsSync(c);
+        t.writeFileSync.apply(t, arguments);
+    }
+    gt = {
+        outputFile: e(o),
+        outputFileSync: c
+    };
+    return gt;
+}
+
+var Ft;
+
+var xt;
+
+function Dt() {
+    if (xt) return Ft;
+    xt = 1;
+    "use strict";
+    const e = _();
+    const t = {};
+    e(t, Y());
+    e(t, me());
+    e(t, De());
+    e(t, se());
+    e(t, Le());
+    e(t, Xe());
+    e(t, Qe());
+    e(t, tt());
+    e(t, it());
+    e(t, bt());
+    e(t, _t());
+    e(t, ae());
+    Ft = t;
+    return Ft;
+}
+
+var Pt;
+
+var Nt;
+
+function jt() {
+    if (Nt) return Pt;
+    Nt = 1;
+    "use strict";
+    var e = Object.defineProperty;
+    var t = Object.getOwnPropertyDescriptor;
+    var n = Object.getOwnPropertyNames;
+    var r = Object.prototype.hasOwnProperty;
+    var i = (t, n) => {
+        for (var r in n) e(t, r, {
+            get: n[r],
+            enumerable: true
+        });
+    };
+    var o = (i, o, c, s) => {
+        if (o && typeof o === "object" || typeof o === "function") {
+            for (let f of n(o)) if (!r.call(i, f) && f !== c) e(i, f, {
+                get: () => o[f],
+                enumerable: !(s = t(o, f)) || s.enumerable
+            });
+        }
+        return i;
+    };
+    var c = t => o(e({}, "__esModule", {
+        value: true
+    }), t);
+    var s = {};
+    i(s, {
+        defaultDeserialize: () => a,
+        defaultSerialize: () => u
+    });
+    Pt = c(s);
+    var f = E.default;
+    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 n = Array.isArray(e);
+            t = n ? "[" : "{";
+            let r = true;
+            for (const i in e) {
+                const o = typeof e[i] === "function" || !n && e[i] === void 0;
+                if (!Object.hasOwn(e, i) || o) {
+                    continue;
+                }
+                if (!r) {
+                    t += ",";
+                }
+                r = false;
+                if (n) {
+                    t += u(e[i]);
+                } else if (e[i] !== void 0) {
+                    t += u(i) + ":" + u(e[i]);
+                }
+            }
+            t += n ? "]" : "}";
+            return t;
+        }
+        return JSON.stringify(e);
+    };
+    var a = 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: a,
+        defaultSerialize: u
+    });
+    return Pt;
+}
+
+(function(e) {
+    "use strict";
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.Field = e.KeyvFile = e.defaultOpts = void 0;
+    e.makeField = f;
+    const t = n.require$$0;
+    const r = t.__importStar(S.default);
+    const i = t.__importStar(Dt());
+    const o = t.__importDefault(k.default);
+    const c = jt();
+    e.defaultOpts = {
+        deserialize: c.defaultDeserialize,
+        dialect: "redis",
+        expiredCheckDelay: 24 * 3600 * 1e3,
+        filename: `${r.tmpdir()}/keyv-file/default.json`,
+        serialize: c.defaultSerialize,
+        writeDelay: 100,
+        checkFileLock: false
+    };
+    function s(e) {
+        return typeof e === "number";
+    }
+    class KeyvFile extends o.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 n in t) {
+                        if (t.hasOwnProperty(n)) {
+                            e.cache.push([ n, t[n] ]);
+                        }
+                    }
+                }
+                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 n = yield Promise.all(e.map((e => t.__awaiter(this, void 0, void 0, (function*() {
+                    const t = yield this.get(e);
+                    return t;
+                })))));
+                return n;
+            }));
+        }
+        set(e, n, r) {
+            return t.__awaiter(this, void 0, void 0, (function*() {
+                if (r === 0) {
+                    r = undefined;
+                }
+                this._cache.set(e, {
+                    expire: s(r) ? Date.now() + r : undefined,
+                    value: n
+                });
+                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 n = yield Promise.all(t);
+                return n.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 s(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, n] of this._cache) {
+                e.push([ t, n ]);
+            }
+            const t = this.opts.serialize({
+                cache: e,
+                lastExpire: this._lastExpire
+            });
+            return new Promise(((e, n) => {
+                i.outputFile(this.opts.filename, t, (t => {
+                    if (t) {
+                        n(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* n() {
+                for (const [n, r] of this._cache.entries()) {
+                    if (n === undefined) {
+                        continue;
+                    }
+                    if (!e || n.includes(e)) {
+                        yield yield t.__await([ n, r.value ]);
+                    }
+                }
+            }));
+        }
+    }
+    e.KeyvFile = KeyvFile;
+    e.default = KeyvFile;
+    class Field {
+        constructor(e, t, n) {
+            this.kv = e;
+            this.key = t;
+            this.defaults = n;
+        }
+        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, n) {
+        return new Field(e, t, n);
+    }
+})(b);
+
+const Tt = t.getDefaultExportFromCjs(b);
+
+async function Mt(t) {
+    return new e.index_default({
+        store: new b.KeyvFile({
+            filename: t.filename,
+            expiredCheckDelay: t.expiredCheckDelay,
+            writeDelay: t.writeDelay
+        }),
+        namespace: t.namespace
+    });
+}
+
+exports.CreateFileCacheAdapter = Mt;