lakutata 2.0.96 → 2.0.97

package/vendor/Package.internal.22.cjs

@@ -1,918 +1,61 @@
-/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:10:51 GMT+0800 (China Standard Time) */
 "use strict";
 
-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;
+const e = require("./Package.internal.51.cjs");
+
+var t = {};
+
+Object.defineProperty(t, "__esModule", {
+    value: true
+});
+
+exports.Column_2 = t.Column = o;
+
+const r = e.requireGlobals();
+
+const n = e.ColumnTypeUndefinedError;
+
+function o(e, t) {
+    return function(o, a) {
+        let s;
+        if (typeof e === "string" || typeof e === "function") {
+            s = e;
+        } else if (e) {
+            t = e;
+            s = e.type;
+        }
+        if (!t) t = {};
+        const i = Reflect && Reflect.getMetadata ? Reflect.getMetadata("design:type", o, a) : undefined;
+        if (!s && i) s = i;
+        if (!t.type && s) t.type = s;
+        if (t.type === "hstore" && !t.hstoreType) t.hstoreType = i === Object ? "object" : "string";
+        if (typeof e === "function") {
+            (0, r.getMetadataArgsStorage)().embeddeds.push({
+                target: o.constructor,
+                propertyName: a,
+                isArray: i === Array || t.array === true,
+                prefix: t.prefix !== undefined ? t.prefix : undefined,
+                type: e
+            });
+        } else {
+            if (!t.type) throw new n.ColumnTypeUndefinedError(o, a);
+            if (t.unique === true) (0, r.getMetadataArgsStorage)().uniques.push({
+                target: o.constructor,
+                columns: [ a ]
+            });
+            (0, r.getMetadataArgsStorage)().columns.push({
+                target: o.constructor,
+                propertyName: a,
+                mode: "regular",
+                options: t
+            });
+            if (t.generated) {
+                (0, r.getMetadataArgsStorage)().generations.push({
+                    target: o.constructor,
+                    propertyName: a,
+                    strategy: typeof t.generated === "string" ? t.generated : "increment"
+                });
+            }
         }
-    }
-}
-
-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;
-    }
-};
-
-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
-        };
-        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);
-    }
-};