ueberdb2 5.0.2 → 5.0.3

package/dist/index.js

@@ -34,7 +34,7 @@
 /**
  * Cache with Least Recently Used eviction policy.
  */
-let LRU$2=class LRU {
+class LRU {
     /**
      * @param evictable Optional predicate that dictates whether it is permissable to evict the entry
      *     if it is old and the cache is over capacity. The predicate is passed two arguments (key,
@@ -95,7 +95,7 @@ let LRU$2=class LRU {
             this._cache.delete(k);
         }
     }
-};
+}
 // Same as Promise but with a `done` property set to a Node-style callback that resolves/rejects the
 // Promise.
 class SelfContainedPromise extends Promise {
@@ -155,7 +155,7 @@ const Database$1 = class Database {
         //     the write to the underlying database returns. If the value has been written this is null.
         //   - writingInProgress: Boolean that if true indicates that the value has been sent to the
         //     underlying database and we are awaiting commit.
-        this.buffer = new LRU$2(this.settings.cache, (k, v) => !v.dirty && !v.writingInProgress);
+        this.buffer = new LRU(this.settings.cache, (k, v) => !v.dirty && !v.writingInProgress);
         // Either null if flushing is currently allowed, or a Promise that will resolve when it is OK to
         // start flushing. The Promise has a `count` property that tracks the number of operations that
         // are currently preventing flush() from running.
@@ -40442,7 +40442,7 @@ var parse$h = function (str, opts) {
 var parse$g = parse$h;
 var formats$1 = formats$4;
 
-var lib$9 = {
+var lib$a = {
     formats: formats$1,
     parse: parse$g,
     stringify: stringify$2
@@ -59656,7 +59656,7 @@ var multipart$1 = MultiPartFactory;(function (module, exports) {
 	const http = http$5;
 	const https = require$$2$2;
 	const assert = require$$0$i;
-	const querystring = lib$9;
+	const querystring = lib$a;
 	const axios = axios_1;
 	const stream = require$$0$b;
 	const pkg = require$$7$2;
@@ -61297,11 +61297,11 @@ class Dirty extends events_1$5.EventEmitter {
         this._writeStream.uncork();
     }
 }
-dirty.default = Dirty;var __importDefault$7 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+dirty.default = Dirty;var __importDefault$6 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(dirty$1, "__esModule", { value: true });
-const dirty_1 = __importDefault$7(dirty);
+const dirty_1 = __importDefault$6(dirty);
 var _default$1 = dirty$1.default = dirty_1.default;/**
  * 2011 Peter 'Pita' Martischka
  *
@@ -67748,7 +67748,7 @@ function __importStar$3(mod) {
     return result;
 }
 
-function __importDefault$6(mod) {
+function __importDefault$5(mod) {
     return (mod && mod.__esModule) ? mod : { default: mod };
 }
 
@@ -67839,13 +67839,13 @@ var _tslib = {
     __asyncValues: __asyncValues,
     __makeTemplateObject: __makeTemplateObject,
     __importStar: __importStar$3,
-    __importDefault: __importDefault$6,
+    __importDefault: __importDefault$5,
     __classPrivateFieldGet: __classPrivateFieldGet$8,
     __classPrivateFieldSet: __classPrivateFieldSet$8,
     __classPrivateFieldIn: __classPrivateFieldIn,
     __addDisposableResource: __addDisposableResource,
     __disposeResources: __disposeResources,
-};var _tslib$1=/*#__PURE__*/Object.freeze({__proto__:null,__addDisposableResource:__addDisposableResource,get __assign(){return __assign},__asyncDelegator:__asyncDelegator,__asyncGenerator:__asyncGenerator,__asyncValues:__asyncValues,__await:__await,__awaiter:__awaiter,__classPrivateFieldGet:__classPrivateFieldGet$8,__classPrivateFieldIn:__classPrivateFieldIn,__classPrivateFieldSet:__classPrivateFieldSet$8,__createBinding:__createBinding$3,__decorate:__decorate,__disposeResources:__disposeResources,__esDecorate:__esDecorate,__exportStar:__exportStar,__extends:__extends,__generator:__generator,__importDefault:__importDefault$6,__importStar:__importStar$3,__makeTemplateObject:__makeTemplateObject,__metadata:__metadata,__param:__param,__propKey:__propKey,__read:__read,__rest:__rest,__runInitializers:__runInitializers,__setFunctionName:__setFunctionName,__spread:__spread,__spreadArray:__spreadArray,__spreadArrays:__spreadArrays,__values:__values,default:_tslib});var require$$0$4 = /*@__PURE__*/getAugmentedNamespace(_tslib$1);var Serializer$4 = {};var secureJsonParse = {exports: {}};var hasRequiredSecureJsonParse;
+};var _tslib$1=/*#__PURE__*/Object.freeze({__proto__:null,__addDisposableResource:__addDisposableResource,get __assign(){return __assign},__asyncDelegator:__asyncDelegator,__asyncGenerator:__asyncGenerator,__asyncValues:__asyncValues,__await:__await,__awaiter:__awaiter,__classPrivateFieldGet:__classPrivateFieldGet$8,__classPrivateFieldIn:__classPrivateFieldIn,__classPrivateFieldSet:__classPrivateFieldSet$8,__createBinding:__createBinding$3,__decorate:__decorate,__disposeResources:__disposeResources,__esDecorate:__esDecorate,__exportStar:__exportStar,__extends:__extends,__generator:__generator,__importDefault:__importDefault$5,__importStar:__importStar$3,__makeTemplateObject:__makeTemplateObject,__metadata:__metadata,__param:__param,__propKey:__propKey,__read:__read,__rest:__rest,__runInitializers:__runInitializers,__setFunctionName:__setFunctionName,__spread:__spread,__spreadArray:__spreadArray,__spreadArrays:__spreadArrays,__values:__values,default:_tslib});var require$$0$4 = /*@__PURE__*/getAugmentedNamespace(_tslib$1);var Serializer$4 = {};var secureJsonParse = {exports: {}};var hasRequiredSecureJsonParse;
 
 function requireSecureJsonParse () {
 	if (hasRequiredSecureJsonParse) return secureJsonParse.exports;
@@ -110178,7 +110178,7 @@ class Elasticsearch_db extends AbstractDatabase {
     set(key, value, cb) {
         this.emit('set', key, value, cb);
     }
-}var lib$8 = {};var admin = {};var bson$2 = {};var bson$1 = {};function isAnyArrayBuffer(value) {
+}var lib$9 = {};var admin = {};var bson$2 = {};var bson$1 = {};function isAnyArrayBuffer(value) {
     return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
 }
 function isUint8Array(value) {
@@ -127068,7 +127068,7 @@ auth_provider.AuthProvider = AuthProvider;(function (exports) {
 	}
 	exports.MongoCredentials = MongoCredentials;
 	
-} (mongo_credentials));var connection_string = {};var lib$7 = {};var whatwgUrl = {};var webidl2jsWrapper = {};var URL$5 = {};var lib$6 = {};(function (exports) {
+} (mongo_credentials));var connection_string = {};var lib$8 = {};var whatwgUrl = {};var webidl2jsWrapper = {};var URL$5 = {};var lib$7 = {};(function (exports) {
 
 	function makeException(ErrorType, message, options) {
 	  if (options.globals) {
@@ -127518,7 +127518,7 @@ auth_provider.AuthProvider = AuthProvider;(function (exports) {
 	};
 
 	exports.DOMTimeStamp = exports["unsigned long long"]; 
-} (lib$6));var utils$a = {exports: {}};(function (module, exports) {
+} (lib$7));var utils$a = {exports: {}};(function (module, exports) {
 
 	// Returns "Type(value) is Object" in ES terminology.
 	function isObject(value) {
@@ -177675,7 +177675,7 @@ function requireUrlencoded () {
 	  serializeUrlencoded
 	};
 	return urlencoded;
-}var URLSearchParams$3 = {};var _Function = {};const conversions = lib$6;
+}var URLSearchParams$3 = {};var _Function = {};const conversions = lib$7;
 const utils$9 = utilsExports$1;
 
 _Function.convert = (globalObject, value, { context = "The provided value" } = {}) => {
@@ -177860,7 +177860,7 @@ function requireURLSearchParamsImpl () {
 	return URLSearchParamsImpl;
 }(function (exports) {
 
-	const conversions = lib$6;
+	const conversions = lib$7;
 	const utils = utilsExports$1;
 
 	const Function = _Function;
@@ -178616,7 +178616,7 @@ function requireURLImpl () {
 	return URLImpl;
 }(function (exports) {
 
-	const conversions = lib$6;
+	const conversions = lib$7;
 	const utils = utilsExports$1;
 
 	const implSymbol = utils.implSymbol;
@@ -179207,7 +179207,7 @@ function requireRedact () {
 }var hasRequiredLib$3;
 
 function requireLib$3 () {
-	if (hasRequiredLib$3) return lib$7;
+	if (hasRequiredLib$3) return lib$8;
 	hasRequiredLib$3 = 1;
 	(function (exports) {
 		Object.defineProperty(exports, "__esModule", { value: true });
@@ -179421,8 +179421,8 @@ function requireLib$3 () {
 		exports.CommaAndColonSeparatedRecord = CommaAndColonSeparatedRecord;
 		exports.default = ConnectionString;
 		
-	} (lib$7));
-	return lib$7;
+	} (lib$8));
+	return lib$8;
 }var client_metadata = {};var name$5 = "mongodb";
 var version$6 = "6.8.1";
 var description$2 = "The official MongoDB driver for Node.js";
@@ -187466,12 +187466,12 @@ function alloc (n) {
 
 function powerOfTwo (x) {
   return !(x & (x - 1))
-}var __importDefault$5 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+}var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(memoryCodePoints, "__esModule", { value: true });
 memoryCodePoints.createMemoryCodePoints = void 0;
-const sparse_bitfield_1 = __importDefault$5(sparseBitfield);
+const sparse_bitfield_1 = __importDefault$4(sparseBitfield);
 function createMemoryCodePoints(data) {
     let offset = 0;
     function read() {
@@ -187499,12 +187499,12 @@ function createMemoryCodePoints(data) {
 memoryCodePoints.createMemoryCodePoints = createMemoryCodePoints;var codePointsData = {};Object.defineProperty(codePointsData, "__esModule", { value: true });
 const zlib_1 = require$$0$e;
 codePointsData.default = (0, zlib_1.gunzipSync)(Buffer.from('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', 'base64'));
-var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const index_1$1 = __importDefault$4(dist$b);
+const index_1$1 = __importDefault$3(dist$b);
 const memory_code_points_1 = memoryCodePoints;
-const code_points_data_1 = __importDefault$4(codePointsData);
+const code_points_data_1 = __importDefault$3(codePointsData);
 const codePoints = (0, memory_code_points_1.createMemoryCodePoints)(code_points_data_1.default);
 function saslprep(input, opts) {
     return (0, index_1$1.default)(codePoints, input, opts);
@@ -190949,7 +190949,7 @@ client_encryption.ClientEncryption = ClientEncryption;(function (exports) {
 	var mongo_client_auth_providers_1 = mongo_client_auth_providers;
 	Object.defineProperty(exports, "MongoClientAuthProviders", { enumerable: true, get: function () { return mongo_client_auth_providers_1.MongoClientAuthProviders; } });
 	
-} (lib$8));/**
+} (lib$9));/**
  * 2020 Sylchauf
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -190994,7 +190994,7 @@ class Mongodb_db extends AbstractDatabase {
         }, 10000);
     }
     init(callback) {
-        lib$8.MongoClient.connect(this.settings.url).then((v) => {
+        lib$9.MongoClient.connect(this.settings.url).then((v) => {
             this.client = v;
             this.database = v.db(this.settings.database);
             this.schedulePing();
@@ -197020,7 +197020,7 @@ var index = {
     wrapSync: asyncify,
     during: whilst$1,
     doDuring: doWhilst$1
-};var tedious$1 = {exports: {}};var base = {exports: {}};var lib$5 = {};var connectionString = {};Object.defineProperty(connectionString, "__esModule", { value: true });
+};var tedious$1 = {exports: {}};var base = {exports: {}};var lib$6 = {};var connectionString = {};Object.defineProperty(connectionString, "__esModule", { value: true });
 var CollectionMode;
 (function (CollectionMode) {
     CollectionMode[CollectionMode["key"] = 0] = "key";
@@ -197517,7 +197517,7 @@ builder.buildConnectionString = buildConnectionString;(function (exports) {
 	exports.parseSqlConnectionString = sql_connection_string_1.default;
 	__exportStar(builder, exports);
 	
-} (lib$5));var tarn$1 = {exports: {}};var Pool$3 = {};var PendingOperation$1 = {};var TimeoutError$3 = {};Object.defineProperty(TimeoutError$3, "__esModule", { value: true });
+} (lib$6));var tarn$1 = {exports: {}};var Pool$3 = {};var PendingOperation$1 = {};var TimeoutError$3 = {};Object.defineProperty(TimeoutError$3, "__esModule", { value: true });
 let TimeoutError$2=class TimeoutError extends Error {
 };
 TimeoutError$3.TimeoutError = TimeoutError$2;var utils$8 = {};var PromiseInspection$1 = {};Object.defineProperty(PromiseInspection$1, "__esModule", { value: true });
@@ -199076,7 +199076,7 @@ var error$2 = {
   TransactionError: TransactionError$3
 };const { EventEmitter: EventEmitter$a } = require$$0$j;
 const debug$c = srcExports('mssql:base');
-const { parseSqlConnectionString } = lib$5;
+const { parseSqlConnectionString } = lib$6;
 const tarn = tarnExports;
 const { IDS: IDS$6 } = utils$7;
 const ConnectionError$3 = connectionError;
@@ -204899,12 +204899,12 @@ helpers$4.req = req;(function (exports) {
 	}
 	exports.Agent = Agent;
 	
-} (dist$9));var parseProxyResponse$1 = {};var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+} (dist$9));var parseProxyResponse$1 = {};var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(parseProxyResponse$1, "__esModule", { value: true });
 parseProxyResponse$1.parseProxyResponse = void 0;
-const debug_1$3 = __importDefault$3(srcExports);
+const debug_1$3 = __importDefault$2(srcExports);
 const debug$8 = (0, debug_1$3.default)('https-proxy-agent:parse-proxy-response');
 function parseProxyResponse(socket) {
     return new Promise((resolve, reject) => {
@@ -205020,15 +205020,15 @@ var __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function
     __setModuleDefault$1(result, mod);
     return result;
 };
-var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(dist$a, "__esModule", { value: true });
 var HttpsProxyAgent_1 = dist$a.HttpsProxyAgent = void 0;
 const net$5 = __importStar$1(require$$0$7);
 const tls$3 = __importStar$1(require$$1$2);
-const assert_1 = __importDefault$2(require$$0$i);
-const debug_1$2 = __importDefault$2(srcExports);
+const assert_1 = __importDefault$1(require$$0$i);
+const debug_1$2 = __importDefault$1(srcExports);
 const agent_base_1$1 = dist$9;
 const url_1$2 = require$$0$f;
 const parse_proxy_response_1 = parseProxyResponse$1;
@@ -205192,14 +205192,14 @@ var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(dist$8, "__esModule", { value: true });
 var HttpProxyAgent_1 = dist$8.HttpProxyAgent = void 0;
 const net$4 = __importStar(require$$0$7);
 const tls$2 = __importStar(require$$1$2);
-const debug_1$1 = __importDefault$1(srcExports);
+const debug_1$1 = __importDefault(srcExports);
 const events_1$2 = require$$0$8;
 const agent_base_1 = dist$9;
 const url_1$1 = require$$0$f;
@@ -219020,7 +219020,7 @@ const coerce$2 = (version, options) => {
 
   return parse$7(`${major}.${minor}.${patch}${prerelease}${build}`, options)
 };
-var coerce_1 = coerce$2;let LRUCache$1=class LRUCache {
+var coerce_1 = coerce$2;class LRUCache {
   constructor () {
     this.max = 1000;
     this.map = new Map();
@@ -219057,9 +219057,9 @@ var coerce_1 = coerce$2;let LRUCache$1=class LRUCache {
 
     return this
   }
-};
+}
 
-var lrucache = LRUCache$1;var range;
+var lrucache = LRUCache;var range;
 var hasRequiredRange;
 
 function requireRange () {
@@ -251785,7 +251785,7 @@ var bigintExports = bigint.exports;var image = {exports: {}};(function (module,
 	
 } (image, image.exports));
 
-var imageExports = image.exports;var text = {exports: {}};var lib$4 = {exports: {}};/* eslint-disable node/no-deprecated-api */
+var imageExports = image.exports;var text = {exports: {}};var lib$5 = {exports: {}};/* eslint-disable node/no-deprecated-api */
 
 var buffer$1 = require$$0$k;
 var Buffer$1 = buffer$1.Buffer;
@@ -263020,9 +263020,9 @@ function requireStreams () {
 	        throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
 	    };
 	}
-} (lib$4));
+} (lib$5));
 
-var libExports$2 = lib$4.exports;(function (module, exports) {
+var libExports$2 = lib$5.exports;(function (module, exports) {
 
 	Object.defineProperty(exports, "__esModule", {
 	  value: true
@@ -273958,1341 +273958,230 @@ Denque.prototype._nextPowerOf2 = function _nextPowerOf2(num) {
   return Math.max(nextPow2, 4);
 };
 
-var denque = Denque;var cjs = {};/**
- * @module LRUCache
- */
-Object.defineProperty(cjs, "__esModule", { value: true });
-cjs.LRUCache = void 0;
-const perf = typeof performance === 'object' &&
-    performance &&
-    typeof performance.now === 'function'
-    ? performance
-    : Date;
-const warned = new Set();
-const emitWarning = (msg, type, code, fn) => {
-    typeof process === 'object' &&
-        process &&
-        typeof process.emitWarning === 'function'
-        ? process.emitWarning(msg, type, code, fn)
-        : console.error(`[${code}] ${type}: ${msg}`);
-};
-const shouldWarn = (code) => !warned.has(code);
-const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
-/* c8 ignore start */
-// This is a little bit ridiculous, tbh.
-// The maximum array length is 2^32-1 or thereabouts on most JS impls.
-// And well before that point, you're caching the entire world, I mean,
-// that's ~32GB of just integers for the next/prev links, plus whatever
-// else to hold that many keys and values.  Just filling the memory with
-// zeroes at init time is brutal when you get that big.
-// But why not be complete?
-// Maybe in the future, these limits will have expanded.
-const getUintArray = (max) => !isPosInt(max)
-    ? null
-    : max <= Math.pow(2, 8)
-        ? Uint8Array
-        : max <= Math.pow(2, 16)
-            ? Uint16Array
-            : max <= Math.pow(2, 32)
-                ? Uint32Array
-                : max <= Number.MAX_SAFE_INTEGER
-                    ? ZeroArray
-                    : null;
-/* c8 ignore stop */
-class ZeroArray extends Array {
-    constructor(size) {
-        super(size);
-        this.fill(0);
-    }
-}
-class Stack {
-    heap;
-    length;
-    // private constructor
-    static #constructing = false;
-    static create(max) {
-        const HeapCls = getUintArray(max);
-        if (!HeapCls)
-            return [];
-        Stack.#constructing = true;
-        const s = new Stack(max, HeapCls);
-        Stack.#constructing = false;
-        return s;
-    }
-    constructor(max, HeapCls) {
-        /* c8 ignore start */
-        if (!Stack.#constructing) {
-            throw new TypeError('instantiate Stack using Stack.create(n)');
-        }
-        /* c8 ignore stop */
-        this.heap = new HeapCls(max);
-        this.length = 0;
-    }
-    push(n) {
-        this.heap[this.length++] = n;
-    }
-    pop() {
-        return this.heap[--this.length];
-    }
-}
-/**
- * Default export, the thing you're using this module to get.
- *
- * All properties from the options object (with the exception of
- * {@link OptionsBase.max} and {@link OptionsBase.maxSize}) are added as
- * normal public members. (`max` and `maxBase` are read-only getters.)
- * Changing any of these will alter the defaults for subsequent method calls,
- * but is otherwise safe.
- */
-class LRUCache {
-    // properties coming in from the options of these, only max and maxSize
-    // really *need* to be protected. The rest can be modified, as they just
-    // set defaults for various methods.
-    #max;
-    #maxSize;
-    #dispose;
-    #disposeAfter;
-    #fetchMethod;
-    /**
-     * {@link LRUCache.OptionsBase.ttl}
-     */
-    ttl;
-    /**
-     * {@link LRUCache.OptionsBase.ttlResolution}
-     */
-    ttlResolution;
-    /**
-     * {@link LRUCache.OptionsBase.ttlAutopurge}
-     */
-    ttlAutopurge;
-    /**
-     * {@link LRUCache.OptionsBase.updateAgeOnGet}
-     */
-    updateAgeOnGet;
-    /**
-     * {@link LRUCache.OptionsBase.updateAgeOnHas}
-     */
-    updateAgeOnHas;
-    /**
-     * {@link LRUCache.OptionsBase.allowStale}
-     */
-    allowStale;
-    /**
-     * {@link LRUCache.OptionsBase.noDisposeOnSet}
-     */
-    noDisposeOnSet;
-    /**
-     * {@link LRUCache.OptionsBase.noUpdateTTL}
-     */
-    noUpdateTTL;
-    /**
-     * {@link LRUCache.OptionsBase.maxEntrySize}
-     */
-    maxEntrySize;
-    /**
-     * {@link LRUCache.OptionsBase.sizeCalculation}
-     */
-    sizeCalculation;
-    /**
-     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
-     */
-    noDeleteOnFetchRejection;
-    /**
-     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
-     */
-    noDeleteOnStaleGet;
-    /**
-     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
-     */
-    allowStaleOnFetchAbort;
-    /**
-     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
-     */
-    allowStaleOnFetchRejection;
-    /**
-     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
-     */
-    ignoreFetchAbort;
-    // computed properties
-    #size;
-    #calculatedSize;
-    #keyMap;
-    #keyList;
-    #valList;
-    #next;
-    #prev;
-    #head;
-    #tail;
-    #free;
-    #disposed;
-    #sizes;
-    #starts;
-    #ttls;
-    #hasDispose;
-    #hasFetchMethod;
-    #hasDisposeAfter;
-    /**
-     * Do not call this method unless you need to inspect the
-     * inner workings of the cache.  If anything returned by this
-     * object is modified in any way, strange breakage may occur.
-     *
-     * These fields are private for a reason!
-     *
-     * @internal
-     */
-    static unsafeExposeInternals(c) {
-        return {
-            // properties
-            starts: c.#starts,
-            ttls: c.#ttls,
-            sizes: c.#sizes,
-            keyMap: c.#keyMap,
-            keyList: c.#keyList,
-            valList: c.#valList,
-            next: c.#next,
-            prev: c.#prev,
-            get head() {
-                return c.#head;
-            },
-            get tail() {
-                return c.#tail;
-            },
-            free: c.#free,
-            // methods
-            isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
-            backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
-            moveToTail: (index) => c.#moveToTail(index),
-            indexes: (options) => c.#indexes(options),
-            rindexes: (options) => c.#rindexes(options),
-            isStale: (index) => c.#isStale(index),
-        };
-    }
-    // Protected read-only members
-    /**
-     * {@link LRUCache.OptionsBase.max} (read-only)
-     */
-    get max() {
-        return this.#max;
-    }
-    /**
-     * {@link LRUCache.OptionsBase.maxSize} (read-only)
-     */
-    get maxSize() {
-        return this.#maxSize;
-    }
-    /**
-     * The total computed size of items in the cache (read-only)
-     */
-    get calculatedSize() {
-        return this.#calculatedSize;
-    }
-    /**
-     * The number of items stored in the cache (read-only)
-     */
-    get size() {
-        return this.#size;
-    }
-    /**
-     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
-     */
-    get fetchMethod() {
-        return this.#fetchMethod;
-    }
-    /**
-     * {@link LRUCache.OptionsBase.dispose} (read-only)
-     */
-    get dispose() {
-        return this.#dispose;
-    }
-    /**
-     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
-     */
-    get disposeAfter() {
-        return this.#disposeAfter;
-    }
-    constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
-        if (max !== 0 && !isPosInt(max)) {
-            throw new TypeError('max option must be a nonnegative integer');
-        }
-        const UintArray = max ? getUintArray(max) : Array;
-        if (!UintArray) {
-            throw new Error('invalid max value: ' + max);
-        }
-        this.#max = max;
-        this.#maxSize = maxSize;
-        this.maxEntrySize = maxEntrySize || this.#maxSize;
-        this.sizeCalculation = sizeCalculation;
-        if (this.sizeCalculation) {
-            if (!this.#maxSize && !this.maxEntrySize) {
-                throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
-            }
-            if (typeof this.sizeCalculation !== 'function') {
-                throw new TypeError('sizeCalculation set to non-function');
-            }
-        }
-        if (fetchMethod !== undefined &&
-            typeof fetchMethod !== 'function') {
-            throw new TypeError('fetchMethod must be a function if specified');
-        }
-        this.#fetchMethod = fetchMethod;
-        this.#hasFetchMethod = !!fetchMethod;
-        this.#keyMap = new Map();
-        this.#keyList = new Array(max).fill(undefined);
-        this.#valList = new Array(max).fill(undefined);
-        this.#next = new UintArray(max);
-        this.#prev = new UintArray(max);
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free = Stack.create(max);
-        this.#size = 0;
-        this.#calculatedSize = 0;
-        if (typeof dispose === 'function') {
-            this.#dispose = dispose;
-        }
-        if (typeof disposeAfter === 'function') {
-            this.#disposeAfter = disposeAfter;
-            this.#disposed = [];
-        }
-        else {
-            this.#disposeAfter = undefined;
-            this.#disposed = undefined;
-        }
-        this.#hasDispose = !!this.#dispose;
-        this.#hasDisposeAfter = !!this.#disposeAfter;
-        this.noDisposeOnSet = !!noDisposeOnSet;
-        this.noUpdateTTL = !!noUpdateTTL;
-        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
-        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
-        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
-        this.ignoreFetchAbort = !!ignoreFetchAbort;
-        // NB: maxEntrySize is set to maxSize if it's set
-        if (this.maxEntrySize !== 0) {
-            if (this.#maxSize !== 0) {
-                if (!isPosInt(this.#maxSize)) {
-                    throw new TypeError('maxSize must be a positive integer if specified');
-                }
-            }
-            if (!isPosInt(this.maxEntrySize)) {
-                throw new TypeError('maxEntrySize must be a positive integer if specified');
-            }
-            this.#initializeSizeTracking();
-        }
-        this.allowStale = !!allowStale;
-        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
-        this.updateAgeOnGet = !!updateAgeOnGet;
-        this.updateAgeOnHas = !!updateAgeOnHas;
-        this.ttlResolution =
-            isPosInt(ttlResolution) || ttlResolution === 0
-                ? ttlResolution
-                : 1;
-        this.ttlAutopurge = !!ttlAutopurge;
-        this.ttl = ttl || 0;
-        if (this.ttl) {
-            if (!isPosInt(this.ttl)) {
-                throw new TypeError('ttl must be a positive integer if specified');
-            }
-            this.#initializeTTLTracking();
-        }
-        // do not allow completely unbounded caches
-        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
-            throw new TypeError('At least one of max, maxSize, or ttl is required');
-        }
-        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
-            const code = 'LRU_CACHE_UNBOUNDED';
-            if (shouldWarn(code)) {
-                warned.add(code);
-                const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
-                    'result in unbounded memory consumption.';
-                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
-            }
-        }
-    }
-    /**
-     * Return the remaining TTL time for a given entry key
-     */
-    getRemainingTTL(key) {
-        return this.#keyMap.has(key) ? Infinity : 0;
-    }
-    #initializeTTLTracking() {
-        const ttls = new ZeroArray(this.#max);
-        const starts = new ZeroArray(this.#max);
-        this.#ttls = ttls;
-        this.#starts = starts;
-        this.#setItemTTL = (index, ttl, start = perf.now()) => {
-            starts[index] = ttl !== 0 ? start : 0;
-            ttls[index] = ttl;
-            if (ttl !== 0 && this.ttlAutopurge) {
-                const t = setTimeout(() => {
-                    if (this.#isStale(index)) {
-                        this.delete(this.#keyList[index]);
-                    }
-                }, ttl + 1);
-                // unref() not supported on all platforms
-                /* c8 ignore start */
-                if (t.unref) {
-                    t.unref();
-                }
-                /* c8 ignore stop */
-            }
-        };
-        this.#updateItemAge = index => {
-            starts[index] = ttls[index] !== 0 ? perf.now() : 0;
-        };
-        this.#statusTTL = (status, index) => {
-            if (ttls[index]) {
-                const ttl = ttls[index];
-                const start = starts[index];
-                status.ttl = ttl;
-                status.start = start;
-                status.now = cachedNow || getNow();
-                status.remainingTTL = status.now + ttl - start;
-            }
-        };
-        // debounce calls to perf.now() to 1s so we're not hitting
-        // that costly call repeatedly.
-        let cachedNow = 0;
-        const getNow = () => {
-            const n = perf.now();
-            if (this.ttlResolution > 0) {
-                cachedNow = n;
-                const t = setTimeout(() => (cachedNow = 0), this.ttlResolution);
-                // not available on all platforms
-                /* c8 ignore start */
-                if (t.unref) {
-                    t.unref();
-                }
-                /* c8 ignore stop */
-            }
-            return n;
-        };
-        this.getRemainingTTL = key => {
-            const index = this.#keyMap.get(key);
-            if (index === undefined) {
-                return 0;
-            }
-            return ttls[index] === 0 || starts[index] === 0
-                ? Infinity
-                : starts[index] + ttls[index] - (cachedNow || getNow());
-        };
-        this.#isStale = index => {
-            return (ttls[index] !== 0 &&
-                starts[index] !== 0 &&
-                (cachedNow || getNow()) - starts[index] > ttls[index]);
-        };
-    }
-    // conditionally set private methods related to TTL
-    #updateItemAge = () => { };
-    #statusTTL = () => { };
-    #setItemTTL = () => { };
-    /* c8 ignore stop */
-    #isStale = () => false;
-    #initializeSizeTracking() {
-        const sizes = new ZeroArray(this.#max);
-        this.#calculatedSize = 0;
-        this.#sizes = sizes;
-        this.#removeItemSize = index => {
-            this.#calculatedSize -= sizes[index];
-            sizes[index] = 0;
-        };
-        this.#requireSize = (k, v, size, sizeCalculation) => {
-            // provisionally accept background fetches.
-            // actual value size will be checked when they return.
-            if (this.#isBackgroundFetch(v)) {
-                return 0;
-            }
-            if (!isPosInt(size)) {
-                if (sizeCalculation) {
-                    if (typeof sizeCalculation !== 'function') {
-                        throw new TypeError('sizeCalculation must be a function');
-                    }
-                    size = sizeCalculation(v, k);
-                    if (!isPosInt(size)) {
-                        throw new TypeError('sizeCalculation return invalid (expect positive integer)');
-                    }
-                }
-                else {
-                    throw new TypeError('invalid size value (must be positive integer). ' +
-                        'When maxSize or maxEntrySize is used, sizeCalculation ' +
-                        'or size must be set.');
-                }
-            }
-            return size;
-        };
-        this.#addItemSize = (index, size, status) => {
-            sizes[index] = size;
-            if (this.#maxSize) {
-                const maxSize = this.#maxSize - sizes[index];
-                while (this.#calculatedSize > maxSize) {
-                    this.#evict(true);
-                }
-            }
-            this.#calculatedSize += sizes[index];
-            if (status) {
-                status.entrySize = size;
-                status.totalCalculatedSize = this.#calculatedSize;
-            }
-        };
-    }
-    #removeItemSize = _i => { };
-    #addItemSize = (_i, _s, _st) => { };
-    #requireSize = (_k, _v, size, sizeCalculation) => {
-        if (size || sizeCalculation) {
-            throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
-        }
-        return 0;
+var denque = Denque;var lib$4 = {};Object.defineProperty(lib$4, "__esModule", { value: true });
+lib$4.createLRU = void 0;
+const createLRU$2 = (options) => {
+    let { max, onEviction } = options;
+    if (!(Number.isInteger(max) && max > 0))
+        throw new TypeError('`max` must be a positive integer');
+    let size = 0;
+    let head = 0;
+    let tail = 0;
+    let free = [];
+    const keyMap = new Map();
+    const keyList = new Array(max).fill(undefined);
+    const valList = new Array(max).fill(undefined);
+    const next = new Array(max).fill(0);
+    const prev = new Array(max).fill(0);
+    const setTail = (index, type) => {
+        if (index === tail)
+            return;
+        const nextIndex = next[index];
+        const prevIndex = prev[index];
+        if (index === head)
+            head = nextIndex;
+        else if (type === 'get' || prevIndex !== 0)
+            next[prevIndex] = nextIndex;
+        if (nextIndex !== 0)
+            prev[nextIndex] = prevIndex;
+        next[tail] = index;
+        prev[index] = tail;
+        next[index] = 0;
+        tail = index;
     };
-    *#indexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-            for (let i = this.#tail; true;) {
-                if (!this.#isValidIndex(i)) {
-                    break;
-                }
-                if (allowStale || !this.#isStale(i)) {
-                    yield i;
-                }
-                if (i === this.#head) {
-                    break;
-                }
-                else {
-                    i = this.#prev[i];
-                }
-            }
-        }
-    }
-    *#rindexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-            for (let i = this.#head; true;) {
-                if (!this.#isValidIndex(i)) {
-                    break;
-                }
-                if (allowStale || !this.#isStale(i)) {
-                    yield i;
-                }
-                if (i === this.#tail) {
-                    break;
-                }
-                else {
-                    i = this.#next[i];
-                }
-            }
-        }
-    }
-    #isValidIndex(index) {
-        return (index !== undefined &&
-            this.#keyMap.get(this.#keyList[index]) === index);
-    }
-    /**
-     * Return a generator yielding `[key, value]` pairs,
-     * in order from most recently used to least recently used.
-     */
-    *entries() {
-        for (const i of this.#indexes()) {
-            if (this.#valList[i] !== undefined &&
-                this.#keyList[i] !== undefined &&
-                !this.#isBackgroundFetch(this.#valList[i])) {
-                yield [this.#keyList[i], this.#valList[i]];
-            }
-        }
-    }
-    /**
-     * Inverse order version of {@link LRUCache.entries}
-     *
-     * Return a generator yielding `[key, value]` pairs,
-     * in order from least recently used to most recently used.
-     */
-    *rentries() {
-        for (const i of this.#rindexes()) {
-            if (this.#valList[i] !== undefined &&
-                this.#keyList[i] !== undefined &&
-                !this.#isBackgroundFetch(this.#valList[i])) {
-                yield [this.#keyList[i], this.#valList[i]];
-            }
-        }
-    }
-    /**
-     * Return a generator yielding the keys in the cache,
-     * in order from most recently used to least recently used.
-     */
-    *keys() {
-        for (const i of this.#indexes()) {
-            const k = this.#keyList[i];
-            if (k !== undefined &&
-                !this.#isBackgroundFetch(this.#valList[i])) {
-                yield k;
-            }
-        }
-    }
-    /**
-     * Inverse order version of {@link LRUCache.keys}
-     *
-     * Return a generator yielding the keys in the cache,
-     * in order from least recently used to most recently used.
-     */
-    *rkeys() {
-        for (const i of this.#rindexes()) {
-            const k = this.#keyList[i];
-            if (k !== undefined &&
-                !this.#isBackgroundFetch(this.#valList[i])) {
-                yield k;
-            }
-        }
-    }
-    /**
-     * Return a generator yielding the values in the cache,
-     * in order from most recently used to least recently used.
-     */
-    *values() {
-        for (const i of this.#indexes()) {
-            const v = this.#valList[i];
-            if (v !== undefined &&
-                !this.#isBackgroundFetch(this.#valList[i])) {
-                yield this.#valList[i];
-            }
-        }
-    }
-    /**
-     * Inverse order version of {@link LRUCache.values}
-     *
-     * Return a generator yielding the values in the cache,
-     * in order from least recently used to most recently used.
-     */
-    *rvalues() {
-        for (const i of this.#rindexes()) {
-            const v = this.#valList[i];
-            if (v !== undefined &&
-                !this.#isBackgroundFetch(this.#valList[i])) {
-                yield this.#valList[i];
-            }
-        }
-    }
-    /**
-     * Iterating over the cache itself yields the same results as
-     * {@link LRUCache.entries}
-     */
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    /**
-     * Find a value for which the supplied fn method returns a truthy value,
-     * similar to Array.find().  fn is called as fn(value, key, cache).
-     */
-    find(fn, getOptions = {}) {
-        for (const i of this.#indexes()) {
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v)
-                ? v.__staleWhileFetching
-                : v;
-            if (value === undefined)
-                continue;
-            if (fn(value, this.#keyList[i], this)) {
-                return this.get(this.#keyList[i], getOptions);
-            }
-        }
-    }
-    /**
-     * Call the supplied function on each item in the cache, in order from
-     * most recently used to least recently used.  fn is called as
-     * fn(value, key, cache).  Does not update age or recenty of use.
-     * Does not iterate over stale values.
-     */
-    forEach(fn, thisp = this) {
-        for (const i of this.#indexes()) {
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v)
-                ? v.__staleWhileFetching
-                : v;
-            if (value === undefined)
-                continue;
-            fn.call(thisp, value, this.#keyList[i], this);
-        }
-    }
-    /**
-     * The same as {@link LRUCache.forEach} but items are iterated over in
-     * reverse order.  (ie, less recently used items are iterated over first.)
-     */
-    rforEach(fn, thisp = this) {
-        for (const i of this.#rindexes()) {
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v)
-                ? v.__staleWhileFetching
-                : v;
-            if (value === undefined)
-                continue;
-            fn.call(thisp, value, this.#keyList[i], this);
-        }
-    }
-    /**
-     * Delete any stale entries. Returns true if anything was removed,
-     * false otherwise.
-     */
-    purgeStale() {
-        let deleted = false;
-        for (const i of this.#rindexes({ allowStale: true })) {
-            if (this.#isStale(i)) {
-                this.delete(this.#keyList[i]);
-                deleted = true;
-            }
-        }
-        return deleted;
-    }
-    /**
-     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-     * passed to cache.load()
-     */
-    dump() {
-        const arr = [];
-        for (const i of this.#indexes({ allowStale: true })) {
-            const key = this.#keyList[i];
-            const v = this.#valList[i];
-            const value = this.#isBackgroundFetch(v)
-                ? v.__staleWhileFetching
-                : v;
-            if (value === undefined || key === undefined)
-                continue;
-            const entry = { value };
-            if (this.#ttls && this.#starts) {
-                entry.ttl = this.#ttls[i];
-                // always dump the start relative to a portable timestamp
-                // it's ok for this to be a bit slow, it's a rare operation.
-                const age = perf.now() - this.#starts[i];
-                entry.start = Math.floor(Date.now() - age);
-            }
-            if (this.#sizes) {
-                entry.size = this.#sizes[i];
-            }
-            arr.unshift([key, entry]);
-        }
-        return arr;
-    }
-    /**
-     * Reset the cache and load in the items in entries in the order listed.
-     * Note that the shape of the resulting cache may be different if the
-     * same options are not used in both caches.
-     */
-    load(arr) {
-        this.clear();
-        for (const [key, entry] of arr) {
-            if (entry.start) {
-                // entry.start is a portable timestamp, but we may be using
-                // node's performance.now(), so calculate the offset, so that
-                // we get the intended remaining TTL, no matter how long it's
-                // been on ice.
-                //
-                // it's ok for this to be a bit slow, it's a rare operation.
-                const age = Date.now() - entry.start;
-                entry.start = perf.now() - age;
-            }
-            this.set(key, entry.value, entry);
-        }
-    }
-    /**
-     * Add a value to the cache.
-     */
-    set(k, v, setOptions = {}) {
-        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
-        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
-        // if the item doesn't fit, don't do anything
-        // NB: maxEntrySize set to maxSize by default
-        if (this.maxEntrySize && size > this.maxEntrySize) {
-            if (status) {
-                status.set = 'miss';
-                status.maxEntrySizeExceeded = true;
-            }
-            // have to delete, in case something is there already.
-            this.delete(k);
-            return this;
-        }
-        let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
-        if (index === undefined) {
-            // addition
-            index = (this.#size === 0
-                ? this.#tail
-                : this.#free.length !== 0
-                    ? this.#free.pop()
-                    : this.#size === this.#max
-                        ? this.#evict(false)
-                        : this.#size);
-            this.#keyList[index] = k;
-            this.#valList[index] = v;
-            this.#keyMap.set(k, index);
-            this.#next[this.#tail] = index;
-            this.#prev[index] = this.#tail;
-            this.#tail = index;
-            this.#size++;
-            this.#addItemSize(index, size, status);
-            if (status)
-                status.set = 'add';
-            noUpdateTTL = false;
-        }
-        else {
-            // update
-            this.#moveToTail(index);
-            const oldVal = this.#valList[index];
-            if (v !== oldVal) {
-                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-                    oldVal.__abortController.abort(new Error('replaced'));
-                }
-                else if (!noDisposeOnSet) {
-                    if (this.#hasDispose) {
-                        this.#dispose?.(oldVal, k, 'set');
-                    }
-                    if (this.#hasDisposeAfter) {
-                        this.#disposed?.push([oldVal, k, 'set']);
-                    }
-                }
-                this.#removeItemSize(index);
-                this.#addItemSize(index, size, status);
-                this.#valList[index] = v;
-                if (status) {
-                    status.set = 'replace';
-                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal)
-                        ? oldVal.__staleWhileFetching
-                        : oldVal;
-                    if (oldValue !== undefined)
-                        status.oldValue = oldValue;
-                }
-            }
-            else if (status) {
-                status.set = 'update';
-            }
-        }
-        if (ttl !== 0 && !this.#ttls) {
-            this.#initializeTTLTracking();
-        }
-        if (this.#ttls) {
-            if (!noUpdateTTL) {
-                this.#setItemTTL(index, ttl, start);
-            }
-            if (status)
-                this.#statusTTL(status, index);
-        }
-        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-            const dt = this.#disposed;
-            let task;
-            while ((task = dt?.shift())) {
-                this.#disposeAfter?.(...task);
+    const _evict = () => {
+        const evictHead = head;
+        const key = keyList[evictHead];
+        onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[evictHead]);
+        keyMap.delete(key);
+        keyList[evictHead] = undefined;
+        valList[evictHead] = undefined;
+        head = next[evictHead];
+        if (head !== 0)
+            prev[head] = 0;
+        size--;
+        if (size === 0)
+            head = tail = 0;
+        free.push(evictHead);
+        return evictHead;
+    };
+    return {
+        /** Adds a key-value pair to the cache. Updates the value if the key already exists. */
+        set(key, value) {
+            if (key === undefined)
+                return;
+            let index = keyMap.get(key);
+            if (index === undefined) {
+                index = size === max ? _evict() : free.length > 0 ? free.pop() : size;
+                keyMap.set(key, index);
+                keyList[index] = key;
+                size++;
             }
-        }
-        return this;
-    }
-    /**
-     * Evict the least recently used item, returning its value or
-     * `undefined` if cache is empty.
-     */
-    pop() {
-        try {
-            while (this.#size) {
-                const val = this.#valList[this.#head];
-                this.#evict(true);
-                if (this.#isBackgroundFetch(val)) {
-                    if (val.__staleWhileFetching) {
-                        return val.__staleWhileFetching;
-                    }
-                }
-                else if (val !== undefined) {
-                    return val;
-                }
+            else
+                onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index]);
+            valList[index] = value;
+            if (size === 1)
+                head = tail = index;
+            else
+                setTail(index, 'set');
+        },
+        /** Retrieves the value for a given key and moves the key to the most recent position. */
+        get(key) {
+            const index = keyMap.get(key);
+            if (index === undefined)
+                return;
+            if (index !== tail)
+                setTail(index, 'get');
+            return valList[index];
+        },
+        /** Retrieves the value for a given key without changing its position. */
+        peek: (key) => {
+            const index = keyMap.get(key);
+            return index !== undefined ? valList[index] : undefined;
+        },
+        /** Checks if a key exists in the cache. */
+        has: (key) => keyMap.has(key),
+        /** Iterates over all keys in the cache, from most recent to least recent. */
+        *keys() {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                yield keyList[current];
+                current = prev[current];
             }
-        }
-        finally {
-            if (this.#hasDisposeAfter && this.#disposed) {
-                const dt = this.#disposed;
-                let task;
-                while ((task = dt?.shift())) {
-                    this.#disposeAfter?.(...task);
-                }
+        },
+        /** Iterates over all values in the cache, from most recent to least recent. */
+        *values() {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                yield valList[current];
+                current = prev[current];
             }
-        }
-    }
-    #evict(free) {
-        const head = this.#head;
-        const k = this.#keyList[head];
-        const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
-            v.__abortController.abort(new Error('evicted'));
-        }
-        else if (this.#hasDispose || this.#hasDisposeAfter) {
-            if (this.#hasDispose) {
-                this.#dispose?.(v, k, 'evict');
+        },
+        /** Iterates over `[key, value]` pairs in the cache, from most recent to least recent. */
+        *entries() {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                yield [keyList[current], valList[current]];
+                current = prev[current];
             }
-            if (this.#hasDisposeAfter) {
-                this.#disposed?.push([v, k, 'evict']);
+        },
+        /** Iterates over each value-key pair in the cache, from most recent to least recent. */
+        forEach: (callback) => {
+            let current = tail;
+            for (let i = 0; i < size; i++) {
+                const key = keyList[current];
+                const value = valList[current];
+                callback(value, key);
+                current = prev[current];
             }
-        }
-        this.#removeItemSize(head);
-        // if we aren't about to use the index, then null these out
-        if (free) {
-            this.#keyList[head] = undefined;
-            this.#valList[head] = undefined;
-            this.#free.push(head);
-        }
-        if (this.#size === 1) {
-            this.#head = this.#tail = 0;
-            this.#free.length = 0;
-        }
-        else {
-            this.#head = this.#next[head];
-        }
-        this.#keyMap.delete(k);
-        this.#size--;
-        return head;
-    }
-    /**
-     * Check if a key is in the cache, without updating the recency of use.
-     * Will return false if the item is stale, even though it is technically
-     * in the cache.
-     *
-     * Will not update item age unless
-     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
-     */
-    has(k, hasOptions = {}) {
-        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== undefined) {
-            const v = this.#valList[index];
-            if (this.#isBackgroundFetch(v) &&
-                v.__staleWhileFetching === undefined) {
+        },
+        /** Deletes a key-value pair from the cache. */
+        delete(key) {
+            const index = keyMap.get(key);
+            if (index === undefined)
                 return false;
+            onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index]);
+            keyMap.delete(key);
+            free.push(index);
+            keyList[index] = undefined;
+            valList[index] = undefined;
+            const prevIndex = prev[index];
+            const nextIndex = next[index];
+            if (prevIndex !== 0)
+                next[prevIndex] = nextIndex;
+            if (nextIndex !== 0)
+                prev[nextIndex] = prevIndex;
+            if (index === head)
+                head = nextIndex;
+            if (index === tail)
+                tail = prevIndex;
+            size--;
+            return true;
+        },
+        /** Evicts the oldest item or the specified number of the oldest items from the cache. */
+        evict: (number) => {
+            let toPrune = Math.min(number, size);
+            while (toPrune > 0) {
+                _evict();
+                toPrune--;
             }
-            if (!this.#isStale(index)) {
-                if (updateAgeOnHas) {
-                    this.#updateItemAge(index);
-                }
-                if (status) {
-                    status.has = 'hit';
-                    this.#statusTTL(status, index);
-                }
-                return true;
-            }
-            else if (status) {
-                status.has = 'stale';
-                this.#statusTTL(status, index);
-            }
-        }
-        else if (status) {
-            status.has = 'miss';
-        }
-        return false;
-    }
-    /**
-     * Like {@link LRUCache#get} but doesn't update recency or delete stale
-     * items.
-     *
-     * Returns `undefined` if the item is stale, unless
-     * {@link LRUCache.OptionsBase.allowStale} is set.
-     */
-    peek(k, peekOptions = {}) {
-        const { allowStale = this.allowStale } = peekOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== undefined &&
-            (allowStale || !this.#isStale(index))) {
-            const v = this.#valList[index];
-            // either stale and allowed, or forcing a refresh of non-stale value
-            return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-        }
-    }
-    #backgroundFetch(k, index, options, context) {
-        const v = index === undefined ? undefined : this.#valList[index];
-        if (this.#isBackgroundFetch(v)) {
-            return v;
-        }
-        const ac = new AbortController();
-        const { signal } = options;
-        // when/if our AC signals, then stop listening to theirs.
-        signal?.addEventListener('abort', () => ac.abort(signal.reason), {
-            signal: ac.signal,
-        });
-        const fetchOpts = {
-            signal: ac.signal,
-            options,
-            context,
-        };
-        const cb = (v, updateCache = false) => {
-            const { aborted } = ac.signal;
-            const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
-            if (options.status) {
-                if (aborted && !updateCache) {
-                    options.status.fetchAborted = true;
-                    options.status.fetchError = ac.signal.reason;
-                    if (ignoreAbort)
-                        options.status.fetchAbortIgnored = true;
-                }
-                else {
-                    options.status.fetchResolved = true;
-                }
-            }
-            if (aborted && !ignoreAbort && !updateCache) {
-                return fetchFail(ac.signal.reason);
-            }
-            // either we didn't abort, and are still here, or we did, and ignored
-            const bf = p;
-            if (this.#valList[index] === p) {
-                if (v === undefined) {
-                    if (bf.__staleWhileFetching) {
-                        this.#valList[index] = bf.__staleWhileFetching;
-                    }
-                    else {
-                        this.delete(k);
-                    }
-                }
-                else {
-                    if (options.status)
-                        options.status.fetchUpdated = true;
-                    this.set(k, v, fetchOpts.options);
-                }
-            }
-            return v;
-        };
-        const eb = (er) => {
-            if (options.status) {
-                options.status.fetchRejected = true;
-                options.status.fetchError = er;
-            }
-            return fetchFail(er);
-        };
-        const fetchFail = (er) => {
-            const { aborted } = ac.signal;
-            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
-            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-            const noDelete = allowStale || options.noDeleteOnFetchRejection;
-            const bf = p;
-            if (this.#valList[index] === p) {
-                // if we allow stale on fetch rejections, then we need to ensure that
-                // the stale value is not removed from the cache when the fetch fails.
-                const del = !noDelete || bf.__staleWhileFetching === undefined;
-                if (del) {
-                    this.delete(k);
-                }
-                else if (!allowStaleAborted) {
-                    // still replace the *promise* with the stale value,
-                    // since we are done with the promise at this point.
-                    // leave it untouched if we're still waiting for an
-                    // aborted background fetch that hasn't yet returned.
-                    this.#valList[index] = bf.__staleWhileFetching;
-                }
-            }
-            if (allowStale) {
-                if (options.status && bf.__staleWhileFetching !== undefined) {
-                    options.status.returnedStale = true;
-                }
-                return bf.__staleWhileFetching;
-            }
-            else if (bf.__returned === bf) {
-                throw er;
-            }
-        };
-        const pcall = (res, rej) => {
-            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-            if (fmp && fmp instanceof Promise) {
-                fmp.then(v => res(v), rej);
-            }
-            // ignored, we go until we finish, regardless.
-            // defer check until we are actually aborting,
-            // so fetchMethod can override.
-            ac.signal.addEventListener('abort', () => {
-                if (!options.ignoreFetchAbort ||
-                    options.allowStaleOnFetchAbort) {
-                    res();
-                    // when it eventually resolves, update the cache.
-                    if (options.allowStaleOnFetchAbort) {
-                        res = v => cb(v, true);
-                    }
-                }
-            });
-        };
-        if (options.status)
-            options.status.fetchDispatched = true;
-        const p = new Promise(pcall).then(cb, eb);
-        const bf = Object.assign(p, {
-            __abortController: ac,
-            __staleWhileFetching: v,
-            __returned: undefined,
-        });
-        if (index === undefined) {
-            // internal, don't expose status.
-            this.set(k, bf, { ...fetchOpts.options, status: undefined });
-            index = this.#keyMap.get(k);
-        }
-        else {
-            this.#valList[index] = bf;
-        }
-        return bf;
-    }
-    #isBackgroundFetch(p) {
-        if (!this.#hasFetchMethod)
-            return false;
-        const b = p;
-        return (!!b &&
-            b instanceof Promise &&
-            b.hasOwnProperty('__staleWhileFetching') &&
-            b.__abortController instanceof AbortController);
-    }
-    async fetch(k, fetchOptions = {}) {
-        const { 
-        // get options
-        allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, 
-        // set options
-        ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, 
-        // fetch exclusive options
-        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal, } = fetchOptions;
-        if (!this.#hasFetchMethod) {
-            if (status)
-                status.fetch = 'get';
-            return this.get(k, {
-                allowStale,
-                updateAgeOnGet,
-                noDeleteOnStaleGet,
-                status,
-            });
-        }
-        const options = {
-            allowStale,
-            updateAgeOnGet,
-            noDeleteOnStaleGet,
-            ttl,
-            noDisposeOnSet,
-            size,
-            sizeCalculation,
-            noUpdateTTL,
-            noDeleteOnFetchRejection,
-            allowStaleOnFetchRejection,
-            allowStaleOnFetchAbort,
-            ignoreFetchAbort,
-            status,
-            signal,
-        };
-        let index = this.#keyMap.get(k);
-        if (index === undefined) {
-            if (status)
-                status.fetch = 'miss';
-            const p = this.#backgroundFetch(k, index, options, context);
-            return (p.__returned = p);
-        }
-        else {
-            // in cache, maybe already fetching
-            const v = this.#valList[index];
-            if (this.#isBackgroundFetch(v)) {
-                const stale = allowStale && v.__staleWhileFetching !== undefined;
-                if (status) {
-                    status.fetch = 'inflight';
-                    if (stale)
-                        status.returnedStale = true;
-                }
-                return stale ? v.__staleWhileFetching : (v.__returned = v);
-            }
-            // if we force a refresh, that means do NOT serve the cached value,
-            // unless we are already in the process of refreshing the cache.
-            const isStale = this.#isStale(index);
-            if (!forceRefresh && !isStale) {
-                if (status)
-                    status.fetch = 'hit';
-                this.#moveToTail(index);
-                if (updateAgeOnGet) {
-                    this.#updateItemAge(index);
-                }
-                if (status)
-                    this.#statusTTL(status, index);
-                return v;
-            }
-            // ok, it is stale or a forced refresh, and not already fetching.
-            // refresh the cache.
-            const p = this.#backgroundFetch(k, index, options, context);
-            const hasStale = p.__staleWhileFetching !== undefined;
-            const staleVal = hasStale && allowStale;
-            if (status) {
-                status.fetch = isStale ? 'stale' : 'refresh';
-                if (staleVal && isStale)
-                    status.returnedStale = true;
-            }
-            return staleVal ? p.__staleWhileFetching : (p.__returned = p);
-        }
-    }
-    /**
-     * Return a value from the cache. Will update the recency of the cache
-     * entry found.
-     *
-     * If the key is not found, get() will return `undefined`.
-     */
-    get(k, getOptions = {}) {
-        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status, } = getOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== undefined) {
-            const value = this.#valList[index];
-            const fetching = this.#isBackgroundFetch(value);
-            if (status)
-                this.#statusTTL(status, index);
-            if (this.#isStale(index)) {
-                if (status)
-                    status.get = 'stale';
-                // delete only if not an in-flight background fetch
-                if (!fetching) {
-                    if (!noDeleteOnStaleGet) {
-                        this.delete(k);
-                    }
-                    if (status && allowStale)
-                        status.returnedStale = true;
-                    return allowStale ? value : undefined;
-                }
-                else {
-                    if (status &&
-                        allowStale &&
-                        value.__staleWhileFetching !== undefined) {
-                        status.returnedStale = true;
-                    }
-                    return allowStale ? value.__staleWhileFetching : undefined;
-                }
-            }
-            else {
-                if (status)
-                    status.get = 'hit';
-                // if we're currently fetching it, we don't actually have it yet
-                // it's not stale, which means this isn't a staleWhileRefetching.
-                // If it's not stale, and fetching, AND has a __staleWhileFetching
-                // value, then that means the user fetched with {forceRefresh:true},
-                // so it's safe to return that value.
-                if (fetching) {
-                    return value.__staleWhileFetching;
-                }
-                this.#moveToTail(index);
-                if (updateAgeOnGet) {
-                    this.#updateItemAge(index);
-                }
-                return value;
-            }
-        }
-        else if (status) {
-            status.get = 'miss';
-        }
-    }
-    #connect(p, n) {
-        this.#prev[n] = p;
-        this.#next[p] = n;
-    }
-    #moveToTail(index) {
-        // if tail already, nothing to do
-        // if head, move head to next[index]
-        // else
-        //   move next[prev[index]] to next[index] (head has no prev)
-        //   move prev[next[index]] to prev[index]
-        // prev[index] = tail
-        // next[tail] = index
-        // tail = index
-        if (index !== this.#tail) {
-            if (index === this.#head) {
-                this.#head = this.#next[index];
-            }
-            else {
-                this.#connect(this.#prev[index], this.#next[index]);
-            }
-            this.#connect(this.#tail, index);
-            this.#tail = index;
-        }
-    }
-    /**
-     * Deletes a key out of the cache.
-     * Returns true if the key was deleted, false otherwise.
-     */
-    delete(k) {
-        let deleted = false;
-        if (this.#size !== 0) {
-            const index = this.#keyMap.get(k);
-            if (index !== undefined) {
-                deleted = true;
-                if (this.#size === 1) {
-                    this.clear();
+        },
+        /** Clears all key-value pairs from the cache. */
+        clear() {
+            for (const index of keyMap.values())
+                onEviction === null || onEviction === void 0 ? void 0 : onEviction(keyList[index], valList[index]);
+            keyMap.clear();
+            keyList.fill(undefined);
+            valList.fill(undefined);
+            free = [];
+            size = 0;
+            head = tail = 0;
+        },
+        /** Resizes the cache to a new maximum size, evicting items if necessary. */
+        resize: (newMax) => {
+            if (!(Number.isInteger(newMax) && newMax > 0))
+                throw new TypeError('`max` must be a positive integer');
+            if (newMax === max)
+                return;
+            if (newMax < max) {
+                let current = tail;
+                const preserve = Math.min(size, newMax);
+                const remove = size - preserve;
+                const newKeyList = new Array(newMax);
+                const newValList = new Array(newMax);
+                const newNext = new Array(newMax);
+                const newPrev = new Array(newMax);
+                for (let i = 1; i <= remove; i++)
+                    onEviction === null || onEviction === void 0 ? void 0 : onEviction(keyList[i], valList[i]);
+                for (let i = preserve - 1; i >= 0; i--) {
+                    newKeyList[i] = keyList[current];
+                    newValList[i] = valList[current];
+                    newNext[i] = i + 1;
+                    newPrev[i] = i - 1;
+                    keyMap.set(newKeyList[i], i);
+                    current = prev[current];
                 }
-                else {
-                    this.#removeItemSize(index);
-                    const v = this.#valList[index];
-                    if (this.#isBackgroundFetch(v)) {
-                        v.__abortController.abort(new Error('deleted'));
-                    }
-                    else if (this.#hasDispose || this.#hasDisposeAfter) {
-                        if (this.#hasDispose) {
-                            this.#dispose?.(v, k, 'delete');
-                        }
-                        if (this.#hasDisposeAfter) {
-                            this.#disposed?.push([v, k, 'delete']);
-                        }
-                    }
-                    this.#keyMap.delete(k);
-                    this.#keyList[index] = undefined;
-                    this.#valList[index] = undefined;
-                    if (index === this.#tail) {
-                        this.#tail = this.#prev[index];
-                    }
-                    else if (index === this.#head) {
-                        this.#head = this.#next[index];
-                    }
-                    else {
-                        this.#next[this.#prev[index]] = this.#next[index];
-                        this.#prev[this.#next[index]] = this.#prev[index];
-                    }
-                    this.#size--;
-                    this.#free.push(index);
+                head = 0;
+                tail = preserve - 1;
+                size = preserve;
+                keyList.length = newMax;
+                valList.length = newMax;
+                next.length = newMax;
+                prev.length = newMax;
+                for (let i = 0; i < preserve; i++) {
+                    keyList[i] = newKeyList[i];
+                    valList[i] = newValList[i];
+                    next[i] = newNext[i];
+                    prev[i] = newPrev[i];
                 }
-            }
-        }
-        if (this.#hasDisposeAfter && this.#disposed?.length) {
-            const dt = this.#disposed;
-            let task;
-            while ((task = dt?.shift())) {
-                this.#disposeAfter?.(...task);
-            }
-        }
-        return deleted;
-    }
-    /**
-     * Clear the cache entirely, throwing away all values.
-     */
-    clear() {
-        for (const index of this.#rindexes({ allowStale: true })) {
-            const v = this.#valList[index];
-            if (this.#isBackgroundFetch(v)) {
-                v.__abortController.abort(new Error('deleted'));
+                free = [];
+                for (let i = preserve; i < newMax; i++)
+                    free.push(i);
             }
             else {
-                const k = this.#keyList[index];
-                if (this.#hasDispose) {
-                    this.#dispose?.(v, k, 'delete');
-                }
-                if (this.#hasDisposeAfter) {
-                    this.#disposed?.push([v, k, 'delete']);
-                }
+                const fill = newMax - max;
+                keyList.push(...new Array(fill).fill(undefined));
+                valList.push(...new Array(fill).fill(undefined));
+                next.push(...new Array(fill).fill(0));
+                prev.push(...new Array(fill).fill(0));
             }
-        }
-        this.#keyMap.clear();
-        this.#valList.fill(undefined);
-        this.#keyList.fill(undefined);
-        if (this.#ttls && this.#starts) {
-            this.#ttls.fill(0);
-            this.#starts.fill(0);
-        }
-        if (this.#sizes) {
-            this.#sizes.fill(0);
-        }
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free.length = 0;
-        this.#calculatedSize = 0;
-        this.#size = 0;
-        if (this.#hasDisposeAfter && this.#disposed) {
-            const dt = this.#disposed;
-            let task;
-            while ((task = dt?.shift())) {
-                this.#disposeAfter?.(...task);
-            }
-        }
-    }
-}
-cjs.LRUCache = LRUCache;
-cjs.default = LRUCache;var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+            max = newMax;
+        },
+        /** Returns the maximum number of items that can be stored in the cache. */
+        get max() {
+            return max;
+        },
+        /** Returns the number of items currently stored in the cache. */
+        get size() {
+            return size;
+        },
+        /** Returns the number of currently available slots in the cache before reaching the maximum size. */
+        get available() {
+            return max - size;
+        },
+    };
 };
-const index_js_1 = __importDefault(cjs);
-var indexCjs = Object.assign(index_js_1.default, { default: index_js_1.default, LRUCache: index_js_1.default });var errors$5 = {};(function (exports) {
+lib$4.createLRU = createLRU$2;var errors$5 = {};(function (exports) {
 
 	// originally copied from https://raw.githubusercontent.com/mysqljs/mysql/7770ee5bb13260c56a160b91fe480d9165dbeeba/lib/protocol/constants/errors.js
 	// (c) node-mysql authors
@@ -279256,9 +278145,9 @@ var indexCjs = Object.assign(index_js_1.default, { default: index_js_1.default,
 	exports[4161] = 'ER_INSTALL_COMPONENT_SET_UNUSED_VALUE';
 	exports[4162] = 'ER_WARN_DEPRECATED_USER_DEFINED_COLLATIONS'; 
 } (errors$5));var string$1 = {};const Iconv = libExports$2;
-const LRU$1 = indexCjs.default;
+const { createLRU: createLRU$1 } = lib$4;
 
-const decoderCache = new LRU$1({
+const decoderCache = createLRU$1({
   max: 500,
 });
 
@@ -284308,9 +283197,9 @@ var genfun = function() {
 };
 
 genfun.formats = formats;
-var generateFunction = genfun;const LRU = indexCjs.default;
+var generateFunction = genfun;const { createLRU } = lib$4;
 
-let parserCache$2 = new LRU({
+const parserCache$2 = createLRU({
   max: 15000,
 });
 
@@ -284359,7 +283248,7 @@ function getParser(type, fields, options, config, compiler) {
 }
 
 function setMaxCache(max) {
-  parserCache$2 = new LRU({ max });
+  parserCache$2.resize(max);
 }
 
 function clearCache() {
@@ -285777,7 +284666,7 @@ var commands$7 = {
   ChangeUser,
   Quit
 };var name$1 = "mysql2";
-var version$2 = "3.11.0";
+var version$2 = "3.11.3";
 var description = "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS";
 var main$1 = "index.js";
 var typings = "typings/mysql/index";
@@ -285834,13 +284723,13 @@ var dependencies$1 = {
 	"generate-function": "^2.3.1",
 	"iconv-lite": "^0.6.3",
 	long: "^5.2.1",
-	"lru-cache": "^8.0.0",
+	"lru.min": "^1.0.0",
 	"named-placeholders": "^1.1.3",
 	"seq-queue": "^0.0.5",
 	sqlstring: "^2.3.2"
 };
 var devDependencies$1 = {
-	"@types/node": "^20.0.0",
+	"@types/node": "^22.0.0",
 	"@typescript-eslint/eslint-plugin": "^5.42.1",
 	"@typescript-eslint/parser": "^5.42.1",
 	"assert-diff": "^3.0.2",
@@ -289660,10 +288549,10 @@ function requirePromise () {
 		    inheritEvents(poolCluster, this, ['warn', 'remove']);
 		  }
 
-		  getConnection() {
+		  getConnection(pattern, selector) {
 		    const corePoolCluster = this.poolCluster;
 		    return new this.Promise((resolve, reject) => {
-		      corePoolCluster.getConnection((err, coreConnection) => {
+		      corePoolCluster.getConnection(pattern, selector, (err, coreConnection) => {
 		        if (err) {
 		          reject(err);
 		        } else {
@@ -291224,7 +290113,7 @@ function requireConnection () {
 	const Readable = require$$0$b.Readable;
 	const Queue = denque;
 	const SqlString = sqlstring;
-	const LRU = indexCjs.default;
+	const { createLRU } = lib$4;
 
 	const PacketParser = packet_parser;
 	const Packets = packetsExports;
@@ -291277,9 +290166,9 @@ function requireConnection () {
 	    this._command = null;
 	    this._paused = false;
 	    this._paused_packets = new Queue();
-	    this._statements = new LRU({
+	    this._statements = createLRU({
 	      max: this.config.maxPreparedStatements,
-	      dispose: function(statement) {
+	      onEviction: function(_, statement) {
 	        statement.close();
 	      }
 	    });
@@ -291613,7 +290502,7 @@ function requireConnection () {
 	    err.code = code || 'PROTOCOL_ERROR';
 	    this.emit('error', err);
 	  }
-	  
+
 	  get fatalError() {
 	    return this._fatalError;
 	  }
@@ -292431,9 +291320,10 @@ function requirePool () {
 	    this._removeIdleTimeoutConnectionsTimer = setTimeout(() => {
 	      try {
 	        while (
-	          this._freeConnections.length > this.config.maxIdle &&
-	          Date.now() - this._freeConnections.get(0).lastActiveTime >
-	            this.config.idleTimeout
+	          this._freeConnections.length > this.config.maxIdle ||
+	          (this._freeConnections.length > 0 &&
+	            Date.now() - this._freeConnections.get(0).lastActiveTime >
+	              this.config.idleTimeout)
 	        ) {
 	          this._freeConnections.get(0).destroy();
 	        }