lakutata 2.0.81 → 2.0.83

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

@@ -312,269 +312,260 @@ function k() {
     return g;
 }
 
-var S;
-
-function w() {
-    if (S) return c;
-    S = 1;
-    (function(e) {
-        "use strict";
-        Object.defineProperty(e, "__esModule", {
-            value: true
-        });
-        e.KeyvFile = e.defaultOpts = void 0;
-        const t = r;
-        const i = t.__importStar(o);
-        const c = t.__importStar(a);
-        const p = t.__importStar(n);
-        const u = t.__importDefault(l);
-        const d = h();
-        const f = t.__importDefault(s);
-        const y = v();
-        t.__exportStar(k(), e);
-        e.defaultOpts = {
-            deserialize: e => (0, d.defaultDeserialize)(e.toString()),
-            dialect: "redis",
-            expiredCheckDelay: 24 * 3600 * 1e3,
-            filename: `${i.tmpdir()}/keyv-file/default.json`,
-            serialize: d.defaultSerialize,
-            writeDelay: 100,
-            checkFileLock: false,
-            separatedFile: false
-        };
-        function m(e) {
-            return typeof e === "number";
-        }
-        class KeyvFile extends u.default {
-            ttlSupport=true;
-            namespace;
-            opts;
-            _data=new Map;
-            _lastExpire=0;
-            _separated;
-            constructor(t) {
-                super();
-                this.opts = Object.assign({}, e.defaultOpts, t);
-                this._separated = new y.SeparatedFileHelper(this.opts);
-                if (this.opts.checkFileLock) {
-                    this.acquireFileLock();
-                }
-                if (this.opts.separatedFile) {
-                    c.mkdirSync(this.opts.filename, {
-                        recursive: true
-                    });
-                    this._lastExpire = this._separated.getLastExpire();
-                } else {
-                    this._loadDataSync();
-                }
+(function(e) {
+    "use strict";
+    Object.defineProperty(e, "__esModule", {
+        value: true
+    });
+    e.KeyvFile = e.defaultOpts = void 0;
+    const t = r;
+    const i = t.__importStar(o);
+    const c = t.__importStar(a);
+    const p = t.__importStar(n);
+    const u = t.__importDefault(l);
+    const d = h();
+    const f = t.__importDefault(s);
+    const y = v();
+    t.__exportStar(k(), e);
+    e.defaultOpts = {
+        deserialize: e => (0, d.defaultDeserialize)(e.toString()),
+        dialect: "redis",
+        expiredCheckDelay: 24 * 3600 * 1e3,
+        filename: `${i.tmpdir()}/keyv-file/default.json`,
+        serialize: d.defaultSerialize,
+        writeDelay: 100,
+        checkFileLock: false,
+        separatedFile: false
+    };
+    function m(e) {
+        return typeof e === "number";
+    }
+    class KeyvFile extends u.default {
+        ttlSupport=true;
+        namespace;
+        opts;
+        _data=new Map;
+        _lastExpire=0;
+        _separated;
+        constructor(t) {
+            super();
+            this.opts = Object.assign({}, e.defaultOpts, t);
+            this._separated = new y.SeparatedFileHelper(this.opts);
+            if (this.opts.checkFileLock) {
+                this.acquireFileLock();
+            }
+            if (this.opts.separatedFile) {
+                c.mkdirSync(this.opts.filename, {
+                    recursive: true
+                });
+                this._lastExpire = this._separated.getLastExpire();
+            } else {
+                this._loadDataSync();
             }
-            _loadDataSync() {
-                try {
-                    const e = this.opts.deserialize(c.readFileSync(this.opts.filename));
-                    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] ]);
-                            }
+        }
+        _loadDataSync() {
+            try {
+                const e = this.opts.deserialize(c.readFileSync(this.opts.filename));
+                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._data = new Map(e.cache);
-                    this._lastExpire = e.lastExpire;
-                } catch (e) {
-                    (0, y.handleIOError)(e);
-                    this._data = new Map;
-                    this._lastExpire = Date.now();
                 }
+                this._data = new Map(e.cache);
+                this._lastExpire = e.lastExpire;
+            } catch (e) {
+                (0, y.handleIOError)(e);
+                this._data = new Map;
+                this._lastExpire = Date.now();
             }
-            get _lockFile() {
-                if (this.opts.separatedFile) {
-                    return this._separated.lockFile;
-                }
-                return this.opts.filename + ".lock";
-            }
-            acquireFileLock() {
-                try {
-                    let e = c.openSync(this._lockFile, "wx");
-                    c.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;
-                }
+        }
+        get _lockFile() {
+            if (this.opts.separatedFile) {
+                return this._separated.lockFile;
             }
-            releaseFileLock() {
-                try {
-                    c.unlinkSync(this._lockFile);
-                } catch (e) {
-                    (0, y.handleIOError)(e);
-                }
+            return this.opts.filename + ".lock";
+        }
+        acquireFileLock() {
+            try {
+                let e = c.openSync(this._lockFile, "wx");
+                c.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;
             }
-            async get(e) {
-                if (this.opts.separatedFile) {
-                    let t = await this._separated.get(e);
-                    return this._getWithExpire(e, t);
-                }
-                return this.getSync(e);
+        }
+        releaseFileLock() {
+            try {
+                c.unlinkSync(this._lockFile);
+            } catch (e) {
+                (0, y.handleIOError)(e);
             }
-            getSync(e) {
-                if (this.opts.separatedFile) {
-                    let t = this._separated.getSync(e);
-                    return this._getWithExpire(e, t);
-                }
-                let t = void 0;
-                try {
-                    const t = this._data.get(e);
-                    return this._getWithExpire(e, t);
-                } catch (e) {
-                    (0, y.handleIOError)(e);
-                }
-                return t;
+        }
+        async get(e) {
+            if (this.opts.separatedFile) {
+                let t = await this._separated.get(e);
+                return this._getWithExpire(e, t);
             }
-            async getMany(e) {
-                if (this.opts.separatedFile) {
-                    return Promise.all(e.map((e => this.get(e))));
-                }
-                return e.map((e => this.getSync(e)));
+            return this.getSync(e);
+        }
+        getSync(e) {
+            if (this.opts.separatedFile) {
+                let t = this._separated.getSync(e);
+                return this._getWithExpire(e, t);
             }
-            async set(e, t, r) {
-                if (r === 0) {
-                    r = undefined;
-                }
-                t = {
-                    expire: m(r) ? Date.now() + r : undefined,
-                    value: t
-                };
-                this.clearExpire();
-                if (this.opts.separatedFile) {
-                    return this._separated.set(e, t);
-                }
-                this._data.set(e, t);
-                return this.save();
+            let t = void 0;
+            try {
+                const t = this._data.get(e);
+                return this._getWithExpire(e, t);
+            } catch (e) {
+                (0, y.handleIOError)(e);
             }
-            async delete(e) {
-                if (this.opts.separatedFile) {
-                    return this._separated.delete(e);
-                }
-                const t = this._data.delete(e);
-                await this.save();
-                return t;
-            }
-            async deleteMany(e) {
-                if (this.opts.separatedFile) {
-                    let t = await Promise.all(e.map((e => this.delete(e))));
-                    return t.every((e => e));
-                }
-                let t = e.every((e => this._data.delete(e)));
-                await this.save();
-                return t;
-            }
-            async clear() {
-                if (this.opts.separatedFile) {
-                    await this._separated.clear();
-                    this._lastExpire = 0;
-                    return true;
-                }
-                this._data = new Map;
-                this._lastExpire = Date.now();
-                return this.save();
+            return t;
+        }
+        async getMany(e) {
+            if (this.opts.separatedFile) {
+                return Promise.all(e.map((e => this.get(e))));
             }
-            async has(e) {
-                const t = await this.get(e);
-                return t !== undefined;
+            return e.map((e => this.getSync(e)));
+        }
+        async set(e, t, r) {
+            if (r === 0) {
+                r = undefined;
             }
-            isExpired(e) {
-                return m(e.expire) && e.expire <= Date.now();
+            t = {
+                expire: m(r) ? Date.now() + r : undefined,
+                value: t
+            };
+            this.clearExpire();
+            if (this.opts.separatedFile) {
+                return this._separated.set(e, t);
             }
-            _getWithExpire(e, t) {
-                if (!t) {
-                    return;
-                }
-                if (this.isExpired(t)) {
-                    this.delete(e);
-                    return;
-                }
-                return t.value;
+            this._data.set(e, t);
+            return this.save();
+        }
+        async delete(e) {
+            if (this.opts.separatedFile) {
+                return this._separated.delete(e);
             }
-            clearExpire() {
-                const e = Date.now();
-                if (e - this._lastExpire <= this.opts.expiredCheckDelay) {
-                    return;
-                }
-                this._lastExpire = e;
-                if (this.opts.separatedFile) {
-                    this._separated.clearExpire((e => this.get(e)));
-                    return;
-                }
-                for (const e of this._data.keys()) {
-                    const t = this._data.get(e);
-                    this._getWithExpire(e, t);
-                }
+            const t = this._data.delete(e);
+            await this.save();
+            return t;
+        }
+        async deleteMany(e) {
+            if (this.opts.separatedFile) {
+                let t = await Promise.all(e.map((e => this.delete(e))));
+                return t.every((e => e));
             }
-            async saveToDisk() {
-                const e = [];
-                for (const [t, r] of this._data) {
-                    e.push([ t, r ]);
-                }
-                const t = this.opts.serialize({
-                    cache: e,
-                    lastExpire: this._lastExpire
-                });
-                await p.mkdir(f.default.dirname(this.opts.filename), {
-                    recursive: true
-                });
-                return p.writeFile(this.opts.filename, t);
+            let t = e.every((e => this._data.delete(e)));
+            await this.save();
+            return t;
+        }
+        async clear() {
+            if (this.opts.separatedFile) {
+                await this._separated.clear();
+                this._lastExpire = 0;
+                return true;
             }
-            _savePromise;
-            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;
+            this._data = new Map;
+            this._lastExpire = Date.now();
+            return this.save();
+        }
+        async has(e) {
+            const t = await this.get(e);
+            return t !== undefined;
+        }
+        isExpired(e) {
+            return m(e.expire) && e.expire <= Date.now();
+        }
+        _getWithExpire(e, t) {
+            if (!t) {
+                return;
             }
-            disconnect() {
-                return Promise.resolve();
+            if (this.isExpired(t)) {
+                this.delete(e);
+                return;
             }
-            async* iterator(e) {
-                let t = this.opts.separatedFile ? await this._separated.entries() : this._data.entries();
-                for (const [r, i] of t) {
-                    if (r === undefined || i === undefined) {
-                        continue;
-                    }
-                    if (!e || r.includes(e)) {
-                        yield [ r, i.value ];
-                    }
+            return t.value;
+        }
+        clearExpire() {
+            const e = Date.now();
+            if (e - this._lastExpire <= this.opts.expiredCheckDelay) {
+                return;
+            }
+            this._lastExpire = e;
+            if (this.opts.separatedFile) {
+                this._separated.clearExpire((e => this.get(e)));
+                return;
+            }
+            for (const e of this._data.keys()) {
+                const t = this._data.get(e);
+                this._getWithExpire(e, t);
+            }
+        }
+        async saveToDisk() {
+            const e = [];
+            for (const [t, r] of this._data) {
+                e.push([ t, r ]);
+            }
+            const t = this.opts.serialize({
+                cache: e,
+                lastExpire: this._lastExpire
+            });
+            await p.mkdir(f.default.dirname(this.opts.filename), {
+                recursive: true
+            });
+            return p.writeFile(this.opts.filename, t);
+        }
+        _savePromise;
+        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();
+        }
+        async* iterator(e) {
+            let t = this.opts.separatedFile ? await this._separated.entries() : this._data.entries();
+            for (const [r, i] of t) {
+                if (r === undefined || i === undefined) {
+                    continue;
+                }
+                if (!e || r.includes(e)) {
+                    yield [ r, i.value ];
                 }
             }
         }
-        e.KeyvFile = KeyvFile;
-        e.default = KeyvFile;
-    })(c);
-    return c;
-}
-
-var x = w();
+    }
+    e.KeyvFile = KeyvFile;
+    e.default = KeyvFile;
+})(c);
 
-const E = t(x);
+const S = t(c);
 
-async function O(t) {
+async function w(t) {
     return new e({
-        store: new x.KeyvFile({
+        store: new c.KeyvFile({
             filename: t.filename,
             expiredCheckDelay: t.expiredCheckDelay,
             writeDelay: t.writeDelay
@@ -583,4 +574,4 @@ async function O(t) {
     });
 }
 
-export { O as CreateFileCacheAdapter };
+export { w as CreateFileCacheAdapter };

package/src/components/docker/ConnectionOptionsBuilder.cjs

@@ -204,7 +204,7 @@ require("../../lib/helpers/UniqueArray.cjs");
 
 require("./options/container/ContainerCommitOptions.cjs");
 
-require("../../../vendor/Package.60.cjs");
+require("../../../vendor/Package.18.cjs");
 
 require("querystring");
 

package/src/components/docker/ConnectionOptionsBuilder.mjs

@@ -198,7 +198,7 @@ import "../../lib/helpers/UniqueArray.mjs";
 
 import "./options/container/ContainerCommitOptions.mjs";
 
-import "../../../vendor/Package.60.mjs";
+import "../../../vendor/Package.18.mjs";
 
 import "querystring";