lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.22.cjs

@@ -1,128 +1,918 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const e = require("./Package.internal.8.cjs");
-
-var t = {
-    exports: {}
-};
-
-t.exports;
-
-let r, i, n, {defineProperty: l, setPrototypeOf: g, create: o, keys: s} = Object, a = "", {round: c, max: b} = Math, h = e => {
-    let t = /([a-f\d]{3,6})/i.exec(e)?.[1], r = t?.length, i = parseInt(6 ^ r ? 3 ^ r ? "0" : t[0] + t[0] + t[1] + t[1] + t[2] + t[2] : t, 16);
-    return [ i >> 16 & 255, i >> 8 & 255, 255 & i ];
-}, u = (e, t, r) => e ^ t || t ^ r ? 16 + 36 * c(e / 51) + 6 * c(t / 51) + c(r / 51) : 8 > e ? 16 : e > 248 ? 231 : c(24 * (e - 8) / 247) + 232, p = e => {
-    let t, r, i, n, l;
-    return 8 > e ? 30 + e : 16 > e ? e - 8 + 90 : (232 > e ? (l = (e -= 16) % 36, t = (e / 36 | 0) / 5, 
-    r = (l / 6 | 0) / 5, i = l % 6 / 5) : t = r = i = (10 * (e - 232) + 8) / 255, n = 2 * b(t, r, i), 
-    n ? 30 + (c(i) << 2 | c(r) << 1 | c(t)) + (2 ^ n ? 0 : 60) : 30);
-}, d = (() => {
-    let e = e => l.some(t => e.test(t)), t = globalThis, n = t.process ?? {}, l = n.argv ?? [], g = n.env ?? {}, o = -1;
-    try {
-        r = "," + s(g).join(",");
-    } catch (e) {
-        g = {}, o = 0;
-    }
-    let a = "FORCE_COLOR", c = {
-        false: 0,
-        0: 0,
-        1: 1,
-        2: 2,
-        3: 3
-    }[g[a]] ?? -1, b = a in g && c || e(/^--color=?(true|always)?$/);
-    return b && (o = c), ~o || (o = ((e, t, n) => (i = e.TERM, {
-        "24bit": 3,
-        truecolor: 3,
-        ansi256: 2,
-        ansi: 1
-    }[e.COLORTERM] || (e.CI ? /,GITHUB/.test(r) ? 3 : 1 : t && "dumb" !== i ? n ? 3 : /-256/.test(i) ? 2 : 1 : 0)))(g, !!g.PM2_HOME || g.NEXT_RUNTIME?.includes("edge") || !!n.stdout?.isTTY, "win32" === n.platform)), 
-    !c || g.NO_COLOR || e(/^--(no-color|color=(false|never))$/) ? 0 : t.window?.chrome || b && !o ? 3 : o;
-})(), f = {
-    open: a,
-    close: a
-}, B = 39, y = 49, w = {}, x = ({p: e}, {open: t, close: r}) => {
-    let i = (e, ...n) => {
-        if (!e) {
-            if (t && t === r) return t;
-            if ((e ?? a) === a) return a;
-        }
-        let l, g = e.raw ? String.raw({
-            raw: e
-        }, ...n) : a + e, o = i.p, s = o.o, c = o.c;
-        if (g.includes("")) for (;o; o = o.p) {
-            let {open: e, close: t} = o, r = t.length, i = a, n = 0;
-            if (r) for (;~(l = g.indexOf(t, n)); n = l + r) i += g.slice(n, l) + e;
-            g = i + g.slice(n);
-        }
-        return s + (g.includes("\n") ? g.replace(/(\r?\n)/g, c + "$1" + s) : g) + c;
-    }, l = t, o = r;
-    return e && (l = e.o + t, o = r + e.c), g(i, n), i.p = {
-        open: t,
-        close: r,
-        o: l,
-        c: o,
-        p: e
-    }, i.open = l, i.close = o, i;
-};
-
-const m = new function e(t = d) {
-    let r = {
-        Ansis: e,
-        level: t,
-        isSupported: () => s,
-        strip: e => e.replace(/[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, a),
-        extend(e) {
-            for (let t in e) {
-                let r = e[t], n = (typeof r)[0];
-                "s" === n ? (i(t, v(...h(r))), i(E(t), C(...h(r)))) : i(t, r, "f" === n);
+const t = require("events");
+
+const e = t => t && t.__esModule ? t : {
+    default: t
+};
+
+const s = e(t);
+
+var i = function(t) {
+    if (typeof t.create !== "function") {
+        throw new TypeError("factory.create must be a function");
+    }
+    if (typeof t.destroy !== "function") {
+        throw new TypeError("factory.destroy must be a function");
+    }
+    if (typeof t.validate !== "undefined" && typeof t.validate !== "function") {
+        throw new TypeError("factory.validate must be a function");
+    }
+};
+
+let r = class PoolDefaults {
+    constructor() {
+        this.fifo = true;
+        this.priorityRange = 1;
+        this.testOnBorrow = false;
+        this.testOnReturn = false;
+        this.autostart = true;
+        this.evictionRunIntervalMillis = 0;
+        this.numTestsPerEvictionRun = 3;
+        this.softIdleTimeoutMillis = -1;
+        this.idleTimeoutMillis = 3e4;
+        this.acquireTimeoutMillis = null;
+        this.destroyTimeoutMillis = null;
+        this.maxWaitingClients = null;
+        this.min = null;
+        this.max = null;
+        this.Promise = Promise;
+    }
+};
+
+var o = r;
+
+const n = o;
+
+let l = class PoolOptions {
+    constructor(t) {
+        const e = new n;
+        t = t || {};
+        this.fifo = typeof t.fifo === "boolean" ? t.fifo : e.fifo;
+        this.priorityRange = t.priorityRange || e.priorityRange;
+        this.testOnBorrow = typeof t.testOnBorrow === "boolean" ? t.testOnBorrow : e.testOnBorrow;
+        this.testOnReturn = typeof t.testOnReturn === "boolean" ? t.testOnReturn : e.testOnReturn;
+        this.autostart = typeof t.autostart === "boolean" ? t.autostart : e.autostart;
+        if (t.acquireTimeoutMillis) {
+            this.acquireTimeoutMillis = parseInt(t.acquireTimeoutMillis, 10);
+        }
+        if (t.destroyTimeoutMillis) {
+            this.destroyTimeoutMillis = parseInt(t.destroyTimeoutMillis, 10);
+        }
+        if (t.maxWaitingClients !== undefined) {
+            this.maxWaitingClients = parseInt(t.maxWaitingClients, 10);
+        }
+        this.max = parseInt(t.max, 10);
+        this.min = parseInt(t.min, 10);
+        this.max = Math.max(isNaN(this.max) ? 1 : this.max, 1);
+        this.min = Math.min(isNaN(this.min) ? 0 : this.min, this.max);
+        this.evictionRunIntervalMillis = t.evictionRunIntervalMillis || e.evictionRunIntervalMillis;
+        this.numTestsPerEvictionRun = t.numTestsPerEvictionRun || e.numTestsPerEvictionRun;
+        this.softIdleTimeoutMillis = t.softIdleTimeoutMillis || e.softIdleTimeoutMillis;
+        this.idleTimeoutMillis = t.idleTimeoutMillis || e.idleTimeoutMillis;
+        this.Promise = t.Promise != null ? t.Promise : e.Promise;
+    }
+};
+
+var a = l;
+
+let h = class Deferred {
+    constructor(t) {
+        this._state = Deferred.PENDING;
+        this._resolve = undefined;
+        this._reject = undefined;
+        this._promise = new t((t, e) => {
+            this._resolve = t;
+            this._reject = e;
+        });
+    }
+    get state() {
+        return this._state;
+    }
+    get promise() {
+        return this._promise;
+    }
+    reject(t) {
+        if (this._state !== Deferred.PENDING) {
+            return;
+        }
+        this._state = Deferred.REJECTED;
+        this._reject(t);
+    }
+    resolve(t) {
+        if (this._state !== Deferred.PENDING) {
+            return;
+        }
+        this._state = Deferred.FULFILLED;
+        this._resolve(t);
+    }
+};
+
+h.PENDING = "PENDING";
+
+h.FULFILLED = "FULFILLED";
+
+h.REJECTED = "REJECTED";
+
+var u = h;
+
+class ExtendableError extends Error {
+    constructor(t) {
+        super(t);
+        this.name = this.constructor.name;
+        this.message = t;
+        if (typeof Error.captureStackTrace === "function") {
+            Error.captureStackTrace(this, this.constructor);
+        } else {
+            this.stack = new Error(t).stack;
+        }
+    }
+}
+
+class TimeoutError extends ExtendableError {
+    constructor(t) {
+        super(t);
+    }
+}
+
+var c = {
+    TimeoutError: TimeoutError
+};
+
+const _ = u;
+
+const d = c;
+
+function f(t, e) {
+    return function s() {
+        return t.apply(e, arguments);
+    };
+}
+
+let m = class ResourceRequest extends _ {
+    constructor(t, e) {
+        super(e);
+        this._creationTimestamp = Date.now();
+        this._timeout = null;
+        if (t !== undefined) {
+            this.setTimeout(t);
+        }
+    }
+    setTimeout(t) {
+        if (this._state !== ResourceRequest.PENDING) {
+            return;
+        }
+        const e = parseInt(t, 10);
+        if (isNaN(e) || e <= 0) {
+            throw new Error("delay must be a positive int");
+        }
+        const s = Date.now() - this._creationTimestamp;
+        if (this._timeout) {
+            this.removeTimeout();
+        }
+        this._timeout = setTimeout(f(this._fireTimeout, this), Math.max(e - s, 0));
+    }
+    removeTimeout() {
+        if (this._timeout) {
+            clearTimeout(this._timeout);
+        }
+        this._timeout = null;
+    }
+    _fireTimeout() {
+        this.reject(new d.TimeoutError("ResourceRequest timed out"));
+    }
+    reject(t) {
+        this.removeTimeout();
+        super.reject(t);
+    }
+    resolve(t) {
+        this.removeTimeout();
+        super.resolve(t);
+    }
+};
+
+var v = m;
+
+const p = u;
+
+let g = class ResourceLoan extends p {
+    constructor(t, e) {
+        super(e);
+        this._creationTimestamp = Date.now();
+        this.pooledResource = t;
+    }
+    reject() {}
+};
+
+var T = g;
+
+const R = {
+    ALLOCATED: "ALLOCATED",
+    IDLE: "IDLE",
+    INVALID: "INVALID",
+    RETURNING: "RETURNING",
+    VALIDATION: "VALIDATION"
+};
+
+var y = R;
+
+const w = y;
+
+let E = class PooledResource {
+    constructor(t) {
+        this.creationTime = Date.now();
+        this.lastReturnTime = null;
+        this.lastBorrowTime = null;
+        this.lastIdleTime = null;
+        this.obj = t;
+        this.state = w.IDLE;
+    }
+    allocate() {
+        this.lastBorrowTime = Date.now();
+        this.state = w.ALLOCATED;
+    }
+    deallocate() {
+        this.lastReturnTime = Date.now();
+        this.state = w.IDLE;
+    }
+    invalidate() {
+        this.state = w.INVALID;
+    }
+    test() {
+        this.state = w.VALIDATION;
+    }
+    idle() {
+        this.lastIdleTime = Date.now();
+        this.state = w.IDLE;
+    }
+    returning() {
+        this.state = w.RETURNING;
+    }
+};
+
+var b = E;
+
+let O = class DefaultEvictor {
+    evict(t, e, s) {
+        const i = Date.now() - e.lastIdleTime;
+        if (t.softIdleTimeoutMillis > 0 && t.softIdleTimeoutMillis < i && t.min < s) {
+            return true;
+        }
+        if (t.idleTimeoutMillis < i) {
+            return true;
+        }
+        return false;
+    }
+};
+
+var I = O;
+
+let P = class DoublyLinkedList {
+    constructor() {
+        this.head = null;
+        this.tail = null;
+        this.length = 0;
+    }
+    insertBeginning(t) {
+        if (this.head === null) {
+            this.head = t;
+            this.tail = t;
+            t.prev = null;
+            t.next = null;
+            this.length++;
+        } else {
+            this.insertBefore(this.head, t);
+        }
+    }
+    insertEnd(t) {
+        if (this.tail === null) {
+            this.insertBeginning(t);
+        } else {
+            this.insertAfter(this.tail, t);
+        }
+    }
+    insertAfter(t, e) {
+        e.prev = t;
+        e.next = t.next;
+        if (t.next === null) {
+            this.tail = e;
+        } else {
+            t.next.prev = e;
+        }
+        t.next = e;
+        this.length++;
+    }
+    insertBefore(t, e) {
+        e.prev = t.prev;
+        e.next = t;
+        if (t.prev === null) {
+            this.head = e;
+        } else {
+            t.prev.next = e;
+        }
+        t.prev = e;
+        this.length++;
+    }
+    remove(t) {
+        if (t.prev === null) {
+            this.head = t.next;
+        } else {
+            t.prev.next = t.next;
+        }
+        if (t.next === null) {
+            this.tail = t.prev;
+        } else {
+            t.next.prev = t.prev;
+        }
+        t.prev = null;
+        t.next = null;
+        this.length--;
+    }
+    static createNode(t) {
+        return {
+            prev: null,
+            next: null,
+            data: t
+        };
+    }
+};
+
+var D = P;
+
+let x = class DoublyLinkedListIterator {
+    constructor(t, e) {
+        this._list = t;
+        this._direction = e === true ? "prev" : "next";
+        this._startPosition = e === true ? "tail" : "head";
+        this._started = false;
+        this._cursor = null;
+        this._done = false;
+    }
+    _start() {
+        this._cursor = this._list[this._startPosition];
+        this._started = true;
+    }
+    _advanceCursor() {
+        if (this._started === false) {
+            this._started = true;
+            this._cursor = this._list[this._startPosition];
+            return;
+        }
+        this._cursor = this._cursor[this._direction];
+    }
+    reset() {
+        this._done = false;
+        this._started = false;
+        this._cursor = null;
+    }
+    remove() {
+        if (this._started === false || this._done === true || this._isCursorDetached()) {
+            return false;
+        }
+        this._list.remove(this._cursor);
+    }
+    next() {
+        if (this._done === true) {
+            return {
+                done: true
+            };
+        }
+        this._advanceCursor();
+        if (this._cursor === null || this._isCursorDetached()) {
+            this._done = true;
+            return {
+                done: true
+            };
+        }
+        return {
+            value: this._cursor,
+            done: false
+        };
+    }
+    _isCursorDetached() {
+        return this._cursor.prev === null && this._cursor.next === null && this._list.tail !== this._cursor && this._list.head !== this._cursor;
+    }
+};
+
+var j = x;
+
+const M = j;
+
+let C = class DequeIterator extends M {
+    next() {
+        const t = super.next();
+        if (t.value) {
+            t.value = t.value.data;
+        }
+        return t;
+    }
+};
+
+var L = C;
+
+const N = D;
+
+const A = L;
+
+let B = class Deque {
+    constructor() {
+        this._list = new N;
+    }
+    shift() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const t = this._list.head;
+        this._list.remove(t);
+        return t.data;
+    }
+    unshift(t) {
+        const e = N.createNode(t);
+        this._list.insertBeginning(e);
+    }
+    push(t) {
+        const e = N.createNode(t);
+        this._list.insertEnd(e);
+    }
+    pop() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const t = this._list.tail;
+        this._list.remove(t);
+        return t.data;
+    }
+    [Symbol.iterator]() {
+        return new A(this._list);
+    }
+    iterator() {
+        return new A(this._list);
+    }
+    reverseIterator() {
+        return new A(this._list, true);
+    }
+    get head() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const t = this._list.head;
+        return t.data;
+    }
+    get tail() {
+        if (this.length === 0) {
+            return undefined;
+        }
+        const t = this._list.tail;
+        return t.data;
+    }
+    get length() {
+        return this._list.length;
+    }
+};
+
+var q = B;
+
+const z = D;
+
+const k = q;
+
+let Q = class Queue extends k {
+    push(t) {
+        const e = z.createNode(t);
+        t.promise.catch(this._createTimeoutRejectionHandler(e));
+        this._list.insertEnd(e);
+    }
+    _createTimeoutRejectionHandler(t) {
+        return e => {
+            if (e.name === "TimeoutError") {
+                this._list.remove(t);
+            }
+        };
+    }
+};
+
+var S = Q;
+
+const G = S;
+
+let W = class PriorityQueue {
+    constructor(t) {
+        this._size = Math.max(+t | 0, 1);
+        this._slots = [];
+        for (let t = 0; t < this._size; t++) {
+            this._slots.push(new G);
+        }
+    }
+    get length() {
+        let t = 0;
+        for (let e = 0, s = this._slots.length; e < s; e++) {
+            t += this._slots[e].length;
+        }
+        return t;
+    }
+    enqueue(t, e) {
+        e = e && +e | 0 || 0;
+        if (e) {
+            if (e < 0 || e >= this._size) {
+                e = this._size - 1;
+            }
+        }
+        this._slots[e].push(t);
+    }
+    dequeue() {
+        for (let t = 0, e = this._slots.length; t < e; t += 1) {
+            if (this._slots[t].length) {
+                return this._slots[t].shift();
+            }
+        }
+        return;
+    }
+    get head() {
+        for (let t = 0, e = this._slots.length; t < e; t += 1) {
+            if (this._slots[t].length > 0) {
+                return this._slots[t].head;
+            }
+        }
+        return;
+    }
+    get tail() {
+        for (let t = this._slots.length - 1; t >= 0; t--) {
+            if (this._slots[t].length > 0) {
+                return this._slots[t].tail;
             }
-            return n = o({}, w), g(r, n), r;
-        }
-    }, i = (e, t, r) => {
-        w[e] = {
-            get() {
-                let i = r ? (...e) => x(this, t(...e)) : x(this, t);
-                return l(this, e, {
-                    value: i
-                }), i;
+        }
+        return;
+    }
+};
+
+var F = W;
+
+var U = {};
+
+function V() {}
+
+U.reflector = function(t) {
+    return t.then(V, V);
+};
+
+const J = s.default.EventEmitter;
+
+const H = i;
+
+const K = a;
+
+const X = v;
+
+const Y = T;
+
+const Z = b;
+
+const $ = u;
+
+const tt = U.reflector;
+
+const et = "factoryCreateError";
+
+const st = "factoryDestroyError";
+
+let it = class Pool extends J {
+    constructor(t, e, s, i, r) {
+        super();
+        H(i);
+        this._config = new K(r);
+        this._Promise = this._config.Promise;
+        this._factory = i;
+        this._draining = false;
+        this._started = false;
+        this._waitingClientsQueue = new s(this._config.priorityRange);
+        this._factoryCreateOperations = new Set;
+        this._factoryDestroyOperations = new Set;
+        this._availableObjects = new e;
+        this._testOnBorrowResources = new Set;
+        this._testOnReturnResources = new Set;
+        this._validationOperations = new Set;
+        this._allObjects = new Set;
+        this._resourceLoans = new Map;
+        this._evictionIterator = this._availableObjects.iterator();
+        this._evictor = new t;
+        this._scheduledEviction = null;
+        if (this._config.autostart === true) {
+            this.start();
+        }
+    }
+    _destroy(t) {
+        t.invalidate();
+        this._allObjects.delete(t);
+        const e = this._factory.destroy(t.obj);
+        const s = this._config.destroyTimeoutMillis ? this._Promise.resolve(this._applyDestroyTimeout(e)) : this._Promise.resolve(e);
+        this._trackOperation(s, this._factoryDestroyOperations).catch(t => {
+            this.emit(st, t);
+        });
+        this._ensureMinimum();
+    }
+    _applyDestroyTimeout(t) {
+        const e = new this._Promise((t, e) => {
+            setTimeout(() => {
+                e(new Error("destroy timed out"));
+            }, this._config.destroyTimeoutMillis).unref();
+        });
+        return this._Promise.race([ e, t ]);
+    }
+    _testOnBorrow() {
+        if (this._availableObjects.length < 1) {
+            return false;
+        }
+        const t = this._availableObjects.shift();
+        t.test();
+        this._testOnBorrowResources.add(t);
+        const e = this._factory.validate(t.obj);
+        const s = this._Promise.resolve(e);
+        this._trackOperation(s, this._validationOperations).then(e => {
+            this._testOnBorrowResources.delete(t);
+            if (e === false) {
+                t.invalidate();
+                this._destroy(t);
+                this._dispense();
+                return;
             }
+            this._dispatchPooledResourceToNextWaitingClient(t);
+        });
+        return true;
+    }
+    _dispatchResource() {
+        if (this._availableObjects.length < 1) {
+            return false;
+        }
+        const t = this._availableObjects.shift();
+        this._dispatchPooledResourceToNextWaitingClient(t);
+        return false;
+    }
+    _dispense() {
+        const t = this._waitingClientsQueue.length;
+        if (t < 1) {
+            return;
+        }
+        const e = t - this._potentiallyAllocableResourceCount;
+        const s = Math.min(this.spareResourceCapacity, e);
+        for (let t = 0; s > t; t++) {
+            this._createResource();
+        }
+        if (this._config.testOnBorrow === true) {
+            const e = t - this._testOnBorrowResources.size;
+            const s = Math.min(this._availableObjects.length, e);
+            for (let t = 0; s > t; t++) {
+                this._testOnBorrow();
+            }
+        }
+        if (this._config.testOnBorrow === false) {
+            const e = Math.min(this._availableObjects.length, t);
+            for (let t = 0; e > t; t++) {
+                this._dispatchResource();
+            }
+        }
+    }
+    _dispatchPooledResourceToNextWaitingClient(t) {
+        const e = this._waitingClientsQueue.dequeue();
+        if (e === undefined || e.state !== $.PENDING) {
+            this._addPooledResourceToAvailableObjects(t);
+            return false;
+        }
+        const s = new Y(t, this._Promise);
+        this._resourceLoans.set(t.obj, s);
+        t.allocate();
+        e.resolve(t.obj);
+        return true;
+    }
+    _trackOperation(t, e) {
+        e.add(t);
+        return t.then(s => {
+            e.delete(t);
+            return this._Promise.resolve(s);
+        }, s => {
+            e.delete(t);
+            return this._Promise.reject(s);
+        });
+    }
+    _createResource() {
+        const t = this._factory.create();
+        const e = this._Promise.resolve(t).then(t => {
+            const e = new Z(t);
+            this._allObjects.add(e);
+            this._addPooledResourceToAvailableObjects(e);
+        });
+        this._trackOperation(e, this._factoryCreateOperations).then(() => {
+            this._dispense();
+            return null;
+        }).catch(t => {
+            this.emit(et, t);
+            this._dispense();
+        });
+    }
+    _ensureMinimum() {
+        if (this._draining === true) {
+            return;
+        }
+        const t = this._config.min - this._count;
+        for (let e = 0; e < t; e++) {
+            this._createResource();
+        }
+    }
+    _evict() {
+        const t = Math.min(this._config.numTestsPerEvictionRun, this._availableObjects.length);
+        const e = {
+            softIdleTimeoutMillis: this._config.softIdleTimeoutMillis,
+            idleTimeoutMillis: this._config.idleTimeoutMillis,
+            min: this._config.min
         };
-    }, s = t > 0, c = (e, t) => s ? {
-        open: `[${e}m`,
-        close: `[${t}m`
-    } : f, b = e => t => e(...h(t)), m = (e, t) => (r, i, n) => c(`${e}8;2;${r};${i};${n}`, t), O = (e, t) => (r, i, n) => c(((e, t, r) => p(u(e, t, r)))(r, i, n) + e, t), R = e => (t, r, i) => e(u(t, r, i)), v = m(3, B), C = m(4, y), $ = e => c("38;5;" + e, B), M = e => c("48;5;" + e, y);
-    2 === t ? (v = R($), C = R(M)) : 1 === t && (v = O(0, B), C = O(10, y), $ = e => c(p(e), B), 
-    M = e => c(p(e) + 10, y));
-    let T, k = {
-        fg: $,
-        bg: M,
-        rgb: v,
-        bgRgb: C,
-        hex: b(v),
-        bgHex: b(C),
-        visible: f,
-        reset: c(0, 0),
-        bold: c(1, 22),
-        dim: c(2, 22),
-        italic: c(3, 23),
-        underline: c(4, 24),
-        inverse: c(7, 27),
-        hidden: c(8, 28),
-        strikethrough: c(9, 29)
-    }, E = e => "bg" + e[0].toUpperCase() + e.slice(1), j = "Bright";
-    return "black,red,green,yellow,blue,magenta,cyan,white,gray".split(",").map((e, t) => {
-        T = E(e), 8 > t ? (k[e + j] = c(90 + t, B), k[T + j] = c(100 + t, y)) : t = 60, 
-        k[e] = c(30 + t, B), k[T] = c(40 + t, y);
-    }), r.extend(k);
-};
-
-t.exports = m, m.default = m;
-
-var O = t.exports;
-
-const R = e.getDefaultExportFromCjs(O);
-
-const {Ansis: v, fg: C, bg: $, rgb: M, bgRgb: T, hex: k, bgHex: E, reset: j, inverse: G, hidden: H, visible: I, bold: P, dim: _, italic: A, underline: L, strikethrough: N, black: U, red: Y, green: q, yellow: F, blue: S, magenta: W, cyan: D, white: X, gray: Z, redBright: z, greenBright: J, yellowBright: K, blueBright: Q, magentaBright: V, cyanBright: ee, whiteBright: te, bgBlack: re, bgRed: ie, bgGreen: ne, bgYellow: le, bgBlue: ge, bgMagenta: oe, bgCyan: se, bgWhite: ae, bgGray: ce, bgRedBright: be, bgGreenBright: he, bgYellowBright: ue, bgBlueBright: pe, bgMagentaBright: de, bgCyanBright: fe, bgWhiteBright: Be} = R;
-
-exports.a = R;
+        for (let s = 0; s < t; ) {
+            const t = this._evictionIterator.next();
+            if (t.done === true && this._availableObjects.length < 1) {
+                this._evictionIterator.reset();
+                return;
+            }
+            if (t.done === true && this._availableObjects.length > 0) {
+                this._evictionIterator.reset();
+                continue;
+            }
+            const i = t.value;
+            const r = this._evictor.evict(e, i, this._availableObjects.length);
+            s++;
+            if (r === true) {
+                this._evictionIterator.remove();
+                this._destroy(i);
+            }
+        }
+    }
+    _scheduleEvictorRun() {
+        if (this._config.evictionRunIntervalMillis > 0) {
+            this._scheduledEviction = setTimeout(() => {
+                this._evict();
+                this._scheduleEvictorRun();
+            }, this._config.evictionRunIntervalMillis).unref();
+        }
+    }
+    _descheduleEvictorRun() {
+        if (this._scheduledEviction) {
+            clearTimeout(this._scheduledEviction);
+        }
+        this._scheduledEviction = null;
+    }
+    start() {
+        if (this._draining === true) {
+            return;
+        }
+        if (this._started === true) {
+            return;
+        }
+        this._started = true;
+        this._scheduleEvictorRun();
+        this._ensureMinimum();
+    }
+    acquire(t) {
+        if (this._started === false && this._config.autostart === false) {
+            this.start();
+        }
+        if (this._draining) {
+            return this._Promise.reject(new Error("pool is draining and cannot accept work"));
+        }
+        if (this.spareResourceCapacity < 1 && this._availableObjects.length < 1 && this._config.maxWaitingClients !== undefined && this._waitingClientsQueue.length >= this._config.maxWaitingClients) {
+            return this._Promise.reject(new Error("max waitingClients count exceeded"));
+        }
+        const e = new X(this._config.acquireTimeoutMillis, this._Promise);
+        this._waitingClientsQueue.enqueue(e, t);
+        this._dispense();
+        return e.promise;
+    }
+    use(t, e) {
+        return this.acquire(e).then(e => t(e).then(t => {
+            this.release(e);
+            return t;
+        }, t => {
+            this.destroy(e);
+            throw t;
+        }));
+    }
+    isBorrowedResource(t) {
+        return this._resourceLoans.has(t);
+    }
+    release(t) {
+        const e = this._resourceLoans.get(t);
+        if (e === undefined) {
+            return this._Promise.reject(new Error("Resource not currently part of this pool"));
+        }
+        this._resourceLoans.delete(t);
+        e.resolve();
+        const s = e.pooledResource;
+        s.deallocate();
+        this._addPooledResourceToAvailableObjects(s);
+        this._dispense();
+        return this._Promise.resolve();
+    }
+    destroy(t) {
+        const e = this._resourceLoans.get(t);
+        if (e === undefined) {
+            return this._Promise.reject(new Error("Resource not currently part of this pool"));
+        }
+        this._resourceLoans.delete(t);
+        e.resolve();
+        const s = e.pooledResource;
+        s.deallocate();
+        this._destroy(s);
+        this._dispense();
+        return this._Promise.resolve();
+    }
+    _addPooledResourceToAvailableObjects(t) {
+        t.idle();
+        if (this._config.fifo === true) {
+            this._availableObjects.push(t);
+        } else {
+            this._availableObjects.unshift(t);
+        }
+    }
+    drain() {
+        this._draining = true;
+        return this.__allResourceRequestsSettled().then(() => this.__allResourcesReturned()).then(() => {
+            this._descheduleEvictorRun();
+        });
+    }
+    __allResourceRequestsSettled() {
+        if (this._waitingClientsQueue.length > 0) {
+            return tt(this._waitingClientsQueue.tail.promise);
+        }
+        return this._Promise.resolve();
+    }
+    __allResourcesReturned() {
+        const t = Array.from(this._resourceLoans.values()).map(t => t.promise).map(tt);
+        return this._Promise.all(t);
+    }
+    clear() {
+        const t = Array.from(this._factoryCreateOperations).map(tt);
+        return this._Promise.all(t).then(() => {
+            for (const t of this._availableObjects) {
+                this._destroy(t);
+            }
+            const t = Array.from(this._factoryDestroyOperations).map(tt);
+            return tt(this._Promise.all(t));
+        });
+    }
+    ready() {
+        return new this._Promise(t => {
+            const e = () => {
+                if (this.available >= this.min) {
+                    t();
+                } else {
+                    setTimeout(e, 100);
+                }
+            };
+            e();
+        });
+    }
+    get _potentiallyAllocableResourceCount() {
+        return this._availableObjects.length + this._testOnBorrowResources.size + this._testOnReturnResources.size + this._factoryCreateOperations.size;
+    }
+    get _count() {
+        return this._allObjects.size + this._factoryCreateOperations.size;
+    }
+    get spareResourceCapacity() {
+        return this._config.max - (this._allObjects.size + this._factoryCreateOperations.size);
+    }
+    get size() {
+        return this._count;
+    }
+    get available() {
+        return this._availableObjects.length;
+    }
+    get borrowed() {
+        return this._resourceLoans.size;
+    }
+    get pending() {
+        return this._waitingClientsQueue.length;
+    }
+    get max() {
+        return this._config.max;
+    }
+    get min() {
+        return this._config.min;
+    }
+};
+
+var rt = it;
+
+const ot = rt;
+
+const nt = q;
+
+const lt = F;
+
+const at = I;
+
+exports.genericPool = {
+    Pool: ot,
+    Deque: nt,
+    PriorityQueue: lt,
+    DefaultEvictor: at,
+    createPool: function(t, e) {
+        return new ot(at, nt, lt, t, e);
+    }
+};