limited-cache 2.2.0 → 2.3.0

package/dist/cjs/index.cjs

@@ -1,403 +1,296 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/core/defaultOptions.ts
+const CURRENT_META_VERSION = 2;
+const MAXIMUM_CACHE_TIME = 365 * 86400 * 1e3;
+const defaultOptions = {
+	maxCacheSize: 100,
+	maxCacheTime: 86400 * 1e3,
+	warnIfItemPurgedBeforeTime: 5e3,
+	opLimit: 200,
+	scanLimit: 50
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+//#endregion
+//#region src/core/lowLevelFunctions.ts
+const positiveNumberOrZero = (value) => Math.max(value, 0) || 0;
+const normalizeOptions = (cacheMetaOptions) => {
+	Object.assign(cacheMetaOptions, {
+		maxCacheSize: positiveNumberOrZero(cacheMetaOptions.maxCacheSize),
+		maxCacheTime: positiveNumberOrZero(cacheMetaOptions.maxCacheTime),
+		opLimit: positiveNumberOrZero(cacheMetaOptions.opLimit)
+	});
+	if (process.env.NODE_ENV !== "production") cacheMetaOptions.warnIfItemPurgedBeforeTime = positiveNumberOrZero(cacheMetaOptions.warnIfItemPurgedBeforeTime);
+	return cacheMetaOptions;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+const isCacheMeta = (cacheMeta) => {
+	return !!cacheMeta?.limitedCacheMetaVersion;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  CURRENT_META_VERSION: () => CURRENT_META_VERSION,
-  LimitedCache: () => LimitedCache,
-  LimitedCacheObject: () => LimitedCacheObject,
-  MAXIMUM_CACHE_TIME: () => MAXIMUM_CACHE_TIME,
-  defaultOptions: () => defaultOptions,
-  getCacheMetaFromObject: () => getCacheMetaFromObject,
-  isCacheMeta: () => isCacheMeta,
-  limitedCacheUtil: () => limitedCacheUtil,
-  lowLevelDoMaintenance: () => lowLevelDoMaintenance,
-  lowLevelGetAll: () => lowLevelGetAll,
-  lowLevelGetOne: () => lowLevelGetOne,
-  lowLevelHas: () => lowLevelHas,
-  lowLevelInit: () => lowLevelInit,
-  lowLevelRemove: () => lowLevelRemove,
-  lowLevelReset: () => lowLevelReset,
-  lowLevelSet: () => lowLevelSet,
-  lowLevelSetOptions: () => lowLevelSetOptions,
-  upgradeCacheMeta: () => upgradeCacheMeta
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/core/defaultOptions.ts
-var CURRENT_META_VERSION = 2;
-var MAXIMUM_CACHE_TIME = 365 * 86400 * 1e3;
-var defaultOptions = {
-  // Public
-  maxCacheSize: 100,
-  maxCacheTime: 86400 * 1e3,
-  // Development-only
-  warnIfItemPurgedBeforeTime: 5e3,
-  // Private
-  opLimit: 200,
-  scanLimit: 50
+const upgradeCacheMeta = (cacheMeta) => {
+	if (!isCacheMeta(cacheMeta)) throw new Error("Limited-cache metadata is missing: please check your usage");
+	if (cacheMeta.limitedCacheMetaVersion !== 2) {
+		console.warn("Limited-cache metadata is from an incompatible version (1). It must be reset.");
+		cacheMeta.limitedCacheMetaVersion = 2;
+		lowLevelReset(cacheMeta);
+	}
 };
-
-// src/core/builtIns.ts
-var {
-  create: objectCreate,
-  assign: objectAssign,
-  prototype: { hasOwnProperty }
-} = Object;
-var dateNow = Date.now;
-
-// src/core/lowLevelFunctions.ts
-var positiveNumberOrZero = (value) => Math.max(value, 0) || 0;
-var normalizeOptions = (cacheMetaOptions) => {
-  objectAssign(cacheMetaOptions, {
-    maxCacheSize: positiveNumberOrZero(cacheMetaOptions.maxCacheSize),
-    maxCacheTime: positiveNumberOrZero(cacheMetaOptions.maxCacheTime),
-    opLimit: positiveNumberOrZero(cacheMetaOptions.opLimit)
-  });
-  if (process.env.NODE_ENV !== "production") {
-    cacheMetaOptions.warnIfItemPurgedBeforeTime = positiveNumberOrZero(
-      cacheMetaOptions.warnIfItemPurgedBeforeTime
-    );
-  }
-  return cacheMetaOptions;
+const lowLevelSetOptions = (cacheMeta, options) => {
+	upgradeCacheMeta(cacheMeta);
+	return normalizeOptions(Object.assign(cacheMeta.options, options));
 };
-var isCacheMeta = (cacheMeta) => {
-  return !!cacheMeta && !!cacheMeta.limitedCacheMetaVersion;
+const lowLevelInit = (optionsOrCacheMeta) => {
+	if (isCacheMeta(optionsOrCacheMeta)) {
+		const existingCacheMeta = optionsOrCacheMeta;
+		upgradeCacheMeta(existingCacheMeta);
+		return existingCacheMeta;
+	}
+	return lowLevelReset({
+		limitedCacheMetaVersion: 2,
+		options: normalizeOptions({
+			...defaultOptions,
+			...optionsOrCacheMeta
+		})
+	});
 };
-var upgradeCacheMeta = (cacheMeta) => {
-  if (!isCacheMeta(cacheMeta)) {
-    throw new Error("Limited-cache metadata is missing: please check your usage");
-  }
-  if (cacheMeta.limitedCacheMetaVersion !== CURRENT_META_VERSION) {
-    console.warn("Limited-cache metadata is from an incompatible version (1). It must be reset.");
-    cacheMeta.limitedCacheMetaVersion = CURRENT_META_VERSION;
-    lowLevelReset(cacheMeta);
-  }
+const _getExpireTime = (cacheMeta, cacheKey) => {
+	const { options: { maxCacheTime }, keyInfo: { [cacheKey]: keyInfo } } = cacheMeta;
+	if (!keyInfo) return 0;
+	const [setTime, expireTime] = keyInfo;
+	return expireTime || setTime + (maxCacheTime || 31536e6);
 };
-var lowLevelSetOptions = (cacheMeta, options) => {
-  upgradeCacheMeta(cacheMeta);
-  return normalizeOptions(objectAssign(cacheMeta.options, options));
+const _cacheKeyHasExpired = (cacheMeta, cacheKey, now) => {
+	return _getExpireTime(cacheMeta, cacheKey) < now;
 };
-var lowLevelInit = (optionsOrCacheMeta) => {
-  if (isCacheMeta(optionsOrCacheMeta)) {
-    const existingCacheMeta = optionsOrCacheMeta;
-    upgradeCacheMeta(existingCacheMeta);
-    return existingCacheMeta;
-  }
-  const fullOptions = normalizeOptions(__spreadValues(__spreadValues({}, defaultOptions), optionsOrCacheMeta));
-  const newCacheMeta = lowLevelReset({
-    limitedCacheMetaVersion: CURRENT_META_VERSION,
-    options: fullOptions
-  });
-  return newCacheMeta;
+const lowLevelDoMaintenance = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	const { cache, keyList, keyInfo } = cacheMeta;
+	const now = Date.now();
+	const [newCache, newKeyList, newKeyInfo] = keyList.reduce((acc, cacheKey) => {
+		const [accCache, accKeyList, accKeyInfo] = acc;
+		if (!_cacheKeyHasExpired(cacheMeta, cacheKey, now)) {
+			accCache[cacheKey] = cache[cacheKey];
+			accKeyList.push(cacheKey);
+			accKeyInfo[cacheKey] = keyInfo[cacheKey];
+		}
+		return acc;
+	}, [
+		{},
+		[],
+		Object.create(null)
+	]);
+	return Object.assign(cacheMeta, {
+		cache: newCache,
+		keyList: newKeyList,
+		keyInfo: newKeyInfo,
+		opsLeft: cacheMeta.options.opLimit
+	});
 };
-var _getExpireTime = (cacheMeta, cacheKey) => {
-  const {
-    options: { maxCacheTime },
-    keyInfo: { [cacheKey]: keyInfo }
-  } = cacheMeta;
-  if (!keyInfo) {
-    return 0;
-  }
-  const [setTime, expireTime] = keyInfo;
-  return expireTime || setTime + (maxCacheTime || MAXIMUM_CACHE_TIME);
+const _removeFromIndex = (cacheMeta, startIndex, now) => {
+	const { cache, keyList, keyInfo } = cacheMeta;
+	let nextIndex = startIndex;
+	let nextCacheKey = keyList[startIndex];
+	const keyListLength = keyList.length;
+	do {
+		cache[nextCacheKey] = keyInfo[nextCacheKey] = void 0;
+		nextIndex++;
+		nextCacheKey = keyList[nextIndex];
+	} while (nextIndex < keyListLength && _cacheKeyHasExpired(cacheMeta, nextCacheKey, now));
+	keyList.splice(startIndex, nextIndex - startIndex);
 };
-var _cacheKeyHasExpired = (cacheMeta, cacheKey, now) => {
-  return _getExpireTime(cacheMeta, cacheKey) < now;
+const _removeItemsToMakeRoom = (cacheMeta, now) => {
+	const { options: { scanLimit, warnIfItemPurgedBeforeTime }, cache, keyList, keyInfo } = cacheMeta;
+	let oldestItemIndex = 0;
+	let oldestExpireTime = _getExpireTime(cacheMeta, keyList[0]);
+	if (oldestExpireTime > now) {
+		let indexToCheck = 0;
+		const maxIndexToCheck = Math.min(keyList.length, scanLimit);
+		while (indexToCheck < maxIndexToCheck) {
+			const cacheKeyForIndex = keyList[indexToCheck];
+			const expireTimeForIndex = _getExpireTime(cacheMeta, cacheKeyForIndex);
+			if (expireTimeForIndex < now) {
+				oldestItemIndex = indexToCheck;
+				oldestExpireTime = 0;
+				break;
+			}
+			if (expireTimeForIndex < oldestExpireTime) {
+				oldestItemIndex = indexToCheck;
+				oldestExpireTime = expireTimeForIndex;
+			}
+			indexToCheck += 1;
+		}
+	}
+	if (process.env.NODE_ENV !== "production" && warnIfItemPurgedBeforeTime && oldestExpireTime > now) {
+		const oldestItemKey = keyList[oldestItemIndex];
+		const [oldestItemSetTime, oldestItemExpireTime] = keyInfo[oldestItemKey];
+		if (now - oldestItemSetTime < warnIfItemPurgedBeforeTime) console.warn("Purged an item from cache while it was still fresh: you may want to increase maxCacheSize", {
+			currentTime: now,
+			key: oldestItemKey,
+			item: cache[oldestItemKey],
+			setTime: oldestItemSetTime,
+			expireTime: oldestItemExpireTime,
+			timeInCache: now - oldestItemSetTime
+		});
+	}
+	_removeFromIndex(cacheMeta, oldestItemIndex, now);
 };
-var lowLevelDoMaintenance = (cacheMeta) => {
-  upgradeCacheMeta(cacheMeta);
-  const { cache, keyList, keyInfo } = cacheMeta;
-  const now = dateNow();
-  const [newCache, newKeyList, newKeyInfo] = keyList.reduce(
-    (acc, cacheKey) => {
-      const [accCache, accKeyList, accKeyInfo] = acc;
-      if (!_cacheKeyHasExpired(cacheMeta, cacheKey, now)) {
-        accCache[cacheKey] = cache[cacheKey];
-        accKeyList.push(cacheKey);
-        accKeyInfo[cacheKey] = keyInfo[cacheKey];
-      }
-      return acc;
-    },
-    [
-      {},
-      [],
-      objectCreate(null)
-    ]
-  );
-  return objectAssign(cacheMeta, {
-    cache: newCache,
-    keyList: newKeyList,
-    keyInfo: newKeyInfo,
-    opsLeft: cacheMeta.options.opLimit
-  });
+const lowLevelHas = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	const { cache } = cacheMeta;
+	if (Object.prototype.hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== void 0) {
+		if (!_cacheKeyHasExpired(cacheMeta, cacheKey, Date.now())) return true;
+		cache[cacheKey] = void 0;
+	}
+	return false;
 };
-var _removeFromIndex = (cacheMeta, startIndex, now) => {
-  const { cache, keyList, keyInfo } = cacheMeta;
-  let nextIndex = startIndex;
-  let nextCacheKey = keyList[startIndex];
-  const keyListLength = keyList.length;
-  do {
-    cache[nextCacheKey] = keyInfo[nextCacheKey] = void 0;
-    nextIndex++;
-    nextCacheKey = keyList[nextIndex];
-  } while (nextIndex < keyListLength && _cacheKeyHasExpired(cacheMeta, nextCacheKey, now));
-  keyList.splice(startIndex, nextIndex - startIndex);
+const lowLevelGetOne = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	if (lowLevelHas(cacheMeta, cacheKey)) return cacheMeta.cache[cacheKey];
 };
-var _removeItemsToMakeRoom = (cacheMeta, now) => {
-  const {
-    options: { scanLimit, warnIfItemPurgedBeforeTime },
-    cache,
-    keyList,
-    keyInfo
-  } = cacheMeta;
-  let oldestItemIndex = 0;
-  let oldestExpireTime = _getExpireTime(cacheMeta, keyList[0]);
-  if (oldestExpireTime > now) {
-    let indexToCheck = 0;
-    const maxIndexToCheck = Math.min(keyList.length, scanLimit);
-    while (indexToCheck < maxIndexToCheck) {
-      const cacheKeyForIndex = keyList[indexToCheck];
-      const expireTimeForIndex = _getExpireTime(cacheMeta, cacheKeyForIndex);
-      if (expireTimeForIndex < now) {
-        oldestItemIndex = indexToCheck;
-        oldestExpireTime = 0;
-        break;
-      }
-      if (expireTimeForIndex < oldestExpireTime) {
-        oldestItemIndex = indexToCheck;
-        oldestExpireTime = expireTimeForIndex;
-      }
-      indexToCheck += 1;
-    }
-  }
-  if (process.env.NODE_ENV !== "production" && warnIfItemPurgedBeforeTime && oldestExpireTime > now) {
-    const oldestItemKey = keyList[oldestItemIndex];
-    const [oldestItemSetTime, oldestItemExpireTime] = keyInfo[oldestItemKey];
-    if (now - oldestItemSetTime < warnIfItemPurgedBeforeTime) {
-      console.warn(
-        "Purged an item from cache while it was still fresh: you may want to increase maxCacheSize",
-        {
-          currentTime: now,
-          key: oldestItemKey,
-          item: cache[oldestItemKey],
-          setTime: oldestItemSetTime,
-          expireTime: oldestItemExpireTime,
-          timeInCache: now - oldestItemSetTime
-        }
-      );
-    }
-  }
-  _removeFromIndex(cacheMeta, oldestItemIndex, now);
+const lowLevelGetAll = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	lowLevelDoMaintenance(cacheMeta);
+	return cacheMeta.cache;
 };
-var lowLevelHas = (cacheMeta, cacheKey) => {
-  upgradeCacheMeta(cacheMeta);
-  const { cache } = cacheMeta;
-  if (hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== void 0) {
-    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, dateNow())) {
-      return true;
-    }
-    cache[cacheKey] = void 0;
-  }
-  return false;
+const lowLevelSet = (cacheMeta, cacheKey, item) => {
+	upgradeCacheMeta(cacheMeta);
+	const { options: { maxCacheSize }, keyList, keyInfo } = cacheMeta;
+	const now = Date.now();
+	const isNew = !keyInfo[cacheKey];
+	if (cacheMeta.cache[cacheKey] !== item) cacheMeta.cache = {
+		...cacheMeta.cache,
+		[cacheKey]: item
+	};
+	keyInfo[cacheKey] = [now, 0];
+	if (isNew) {
+		keyList.push(cacheKey);
+		cacheMeta.opsLeft--;
+		if (cacheMeta.opsLeft <= 0) lowLevelDoMaintenance(cacheMeta);
+		if (maxCacheSize && cacheMeta.keyList.length > maxCacheSize) _removeItemsToMakeRoom(cacheMeta, now);
+	}
+	if (_cacheKeyHasExpired(cacheMeta, keyList[0], now)) _removeFromIndex(cacheMeta, 0, now);
+	return cacheMeta;
 };
-var lowLevelGetOne = (cacheMeta, cacheKey) => {
-  upgradeCacheMeta(cacheMeta);
-  if (lowLevelHas(cacheMeta, cacheKey)) {
-    return cacheMeta.cache[cacheKey];
-  }
-  return;
+const lowLevelRemove = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	const { cache, keyInfo } = cacheMeta;
+	if (keyInfo[cacheKey]) {
+		if (cache[cacheKey] !== void 0) cacheMeta.cache = {
+			...cache,
+			[cacheKey]: void 0
+		};
+		keyInfo[cacheKey] = void 0;
+	}
+	return cacheMeta;
 };
-var lowLevelGetAll = (cacheMeta) => {
-  upgradeCacheMeta(cacheMeta);
-  lowLevelDoMaintenance(cacheMeta);
-  return cacheMeta.cache;
+const lowLevelReset = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	return Object.assign(cacheMeta, {
+		cache: {},
+		keyList: [],
+		keyInfo: Object.create(null),
+		opsLeft: cacheMeta.options.opLimit
+	});
 };
-var lowLevelSet = (cacheMeta, cacheKey, item) => {
-  upgradeCacheMeta(cacheMeta);
-  const {
-    options: { maxCacheSize },
-    keyList,
-    keyInfo
-  } = cacheMeta;
-  const now = dateNow();
-  const isNew = !keyInfo[cacheKey];
-  if (cacheMeta.cache[cacheKey] !== item) {
-    cacheMeta.cache = __spreadProps(__spreadValues({}, cacheMeta.cache), {
-      [cacheKey]: item
-    });
-  }
-  keyInfo[cacheKey] = [now, 0];
-  if (isNew) {
-    keyList.push(cacheKey);
-    cacheMeta.opsLeft--;
-    if (cacheMeta.opsLeft <= 0) {
-      lowLevelDoMaintenance(cacheMeta);
-    }
-    if (maxCacheSize && cacheMeta.keyList.length > maxCacheSize) {
-      _removeItemsToMakeRoom(cacheMeta, now);
-    }
-  }
-  if (_cacheKeyHasExpired(cacheMeta, keyList[0], now)) {
-    _removeFromIndex(cacheMeta, 0, now);
-  }
-  return cacheMeta;
+//#endregion
+//#region src/core/LimitedCache.ts
+const bindFunctionToCacheMeta = (fn, cacheMeta) => fn.bind(null, cacheMeta);
+const LimitedCache = (options) => {
+	const cacheMeta = lowLevelInit(options);
+	return {
+		get: bindFunctionToCacheMeta(lowLevelGetOne, cacheMeta),
+		getAll: bindFunctionToCacheMeta(lowLevelGetAll, cacheMeta),
+		has: bindFunctionToCacheMeta(lowLevelHas, cacheMeta),
+		set: (cacheKey, item) => {
+			lowLevelSet(cacheMeta, cacheKey, item);
+			return item;
+		},
+		remove: (cacheKey) => {
+			lowLevelRemove(cacheMeta, cacheKey);
+			return true;
+		},
+		reset: bindFunctionToCacheMeta(lowLevelReset, cacheMeta),
+		getCacheMeta: () => cacheMeta,
+		getOptions: () => cacheMeta.options,
+		setOptions: bindFunctionToCacheMeta(lowLevelSetOptions, cacheMeta),
+		doMaintenance: bindFunctionToCacheMeta(lowLevelDoMaintenance, cacheMeta)
+	};
 };
-var lowLevelRemove = (cacheMeta, cacheKey) => {
-  upgradeCacheMeta(cacheMeta);
-  const { cache, keyInfo } = cacheMeta;
-  if (keyInfo[cacheKey]) {
-    if (cache[cacheKey] !== void 0) {
-      cacheMeta.cache = __spreadProps(__spreadValues({}, cache), {
-        [cacheKey]: void 0
-      });
-    }
-    keyInfo[cacheKey] = void 0;
-  }
-  return cacheMeta;
+//#endregion
+//#region src/core/LimitedCacheObject.ts
+const proxyHandler = {
+	get: (cacheMeta, cacheKey) => {
+		if (cacheKey === "hasOwnProperty") return Object.prototype.hasOwnProperty;
+		return lowLevelGetOne(cacheMeta, cacheKey);
+	},
+	getOwnPropertyDescriptor: (cacheMeta, cacheKey) => {
+		const hasResult = lowLevelHas(cacheMeta, cacheKey);
+		const getResult = lowLevelGetOne(cacheMeta, cacheKey);
+		if (hasResult) return {
+			configurable: true,
+			enumerable: hasResult,
+			value: getResult,
+			writable: true
+		};
+	},
+	has: lowLevelHas,
+	set: (cacheMeta, cacheKey, item) => {
+		lowLevelSet(cacheMeta, cacheKey, item);
+		return item;
+	},
+	deleteProperty: (cacheMeta, cacheKey) => {
+		lowLevelRemove(cacheMeta, cacheKey);
+		return true;
+	},
+	ownKeys: (cacheMeta) => Object.keys(lowLevelGetAll(cacheMeta))
 };
-var lowLevelReset = (cacheMeta) => {
-  upgradeCacheMeta(cacheMeta);
-  return objectAssign(cacheMeta, {
-    cache: {},
-    keyList: [],
-    keyInfo: objectCreate(null),
-    opsLeft: cacheMeta.options.opLimit
-  });
+/**
+* TypeScript's Proxy type models the runtime target, but LimitedCacheObject intentionally returns
+* a facade with a different surface from the internal cache metadata target.
+*/
+const internal_createLimitedCacheObjectProxy = (cacheMeta) => {
+	return new Proxy(cacheMeta, proxyHandler);
 };
-
-// src/core/LimitedCache.ts
-var bindFunctionToCacheMeta = (fn, cacheMeta) => fn.bind(null, cacheMeta);
-var LimitedCache = (options) => {
-  const cacheMeta = lowLevelInit(options);
-  return {
-    get: bindFunctionToCacheMeta(lowLevelGetOne, cacheMeta),
-    getAll: bindFunctionToCacheMeta(lowLevelGetAll, cacheMeta),
-    has: bindFunctionToCacheMeta(lowLevelHas, cacheMeta),
-    set: (cacheKey, item) => {
-      lowLevelSet(cacheMeta, cacheKey, item);
-      return item;
-    },
-    remove: (cacheKey) => {
-      lowLevelRemove(cacheMeta, cacheKey);
-      return true;
-    },
-    reset: bindFunctionToCacheMeta(lowLevelReset, cacheMeta),
-    getCacheMeta: () => cacheMeta,
-    getOptions: () => cacheMeta.options,
-    setOptions: bindFunctionToCacheMeta(lowLevelSetOptions, cacheMeta),
-    doMaintenance: bindFunctionToCacheMeta(lowLevelDoMaintenance, cacheMeta)
-  };
+/**
+* So that we can retrieve the cacheMeta for a LimitedCacheObject, without polluting its properties, each proxy
+* is associated back to its internal cacheMeta here.
+*/
+const cacheMetasForProxies = /* @__PURE__ */ new WeakMap();
+const LimitedCacheObject = (options) => {
+	const cacheMeta = lowLevelInit(options);
+	const limitedCacheObject = internal_createLimitedCacheObjectProxy(cacheMeta);
+	cacheMetasForProxies.set(limitedCacheObject, cacheMeta);
+	return limitedCacheObject;
 };
-
-// src/core/LimitedCacheObject.ts
-var proxyHandler = {
-  get: (cacheMeta, cacheKey) => {
-    if (cacheKey === "hasOwnProperty") {
-      return hasOwnProperty;
-    }
-    return lowLevelGetOne(cacheMeta, cacheKey);
-  },
-  getOwnPropertyDescriptor: (cacheMeta, cacheKey) => {
-    const hasResult = lowLevelHas(cacheMeta, cacheKey);
-    const getResult = lowLevelGetOne(cacheMeta, cacheKey);
-    if (hasResult) {
-      return {
-        configurable: true,
-        enumerable: hasResult,
-        value: getResult,
-        writable: true
-      };
-    }
-    return;
-  },
-  has: lowLevelHas,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  set: (cacheMeta, cacheKey, item) => {
-    lowLevelSet(cacheMeta, cacheKey, item);
-    return item;
-  },
-  deleteProperty: (cacheMeta, cacheKey) => {
-    lowLevelRemove(cacheMeta, cacheKey);
-    return true;
-  },
-  ownKeys: (cacheMeta) => Object.keys(lowLevelGetAll(cacheMeta))
+const getCacheMetaFromObject = (instance) => {
+	return cacheMetasForProxies.get(instance);
 };
-var cacheMetasForProxies = /* @__PURE__ */ new WeakMap();
-var LimitedCacheObject = (options) => {
-  const cacheMeta = lowLevelInit(options);
-  const limitedCacheObject = new Proxy(cacheMeta, proxyHandler);
-  cacheMetasForProxies.set(limitedCacheObject, cacheMeta);
-  return limitedCacheObject;
+//#endregion
+//#region src/core/limitedCacheUtil.ts
+const limitedCacheUtil = {
+	init: lowLevelInit,
+	get: lowLevelGetOne,
+	getAll: lowLevelGetAll,
+	has: lowLevelHas,
+	set: lowLevelSet,
+	remove: lowLevelRemove,
+	reset: lowLevelReset,
+	doMaintenance: lowLevelDoMaintenance,
+	setOptions: lowLevelSetOptions
 };
-var getCacheMetaFromObject = (instance) => {
-  return cacheMetasForProxies.get(instance);
-};
-
-// src/core/limitedCacheUtil.ts
-var limitedCacheUtil = {
-  init: lowLevelInit,
-  get: lowLevelGetOne,
-  getAll: lowLevelGetAll,
-  has: lowLevelHas,
-  set: lowLevelSet,
-  remove: lowLevelRemove,
-  reset: lowLevelReset,
-  doMaintenance: lowLevelDoMaintenance,
-  setOptions: lowLevelSetOptions
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CURRENT_META_VERSION,
-  LimitedCache,
-  LimitedCacheObject,
-  MAXIMUM_CACHE_TIME,
-  defaultOptions,
-  getCacheMetaFromObject,
-  isCacheMeta,
-  limitedCacheUtil,
-  lowLevelDoMaintenance,
-  lowLevelGetAll,
-  lowLevelGetOne,
-  lowLevelHas,
-  lowLevelInit,
-  lowLevelRemove,
-  lowLevelReset,
-  lowLevelSet,
-  lowLevelSetOptions,
-  upgradeCacheMeta
-});
+//#endregion
+exports.CURRENT_META_VERSION = CURRENT_META_VERSION;
+exports.LimitedCache = LimitedCache;
+exports.LimitedCacheObject = LimitedCacheObject;
+exports.MAXIMUM_CACHE_TIME = MAXIMUM_CACHE_TIME;
+exports.defaultOptions = defaultOptions;
+exports.getCacheMetaFromObject = getCacheMetaFromObject;
+exports.isCacheMeta = isCacheMeta;
+exports.limitedCacheUtil = limitedCacheUtil;
+exports.lowLevelDoMaintenance = lowLevelDoMaintenance;
+exports.lowLevelGetAll = lowLevelGetAll;
+exports.lowLevelGetOne = lowLevelGetOne;
+exports.lowLevelHas = lowLevelHas;
+exports.lowLevelInit = lowLevelInit;
+exports.lowLevelRemove = lowLevelRemove;
+exports.lowLevelReset = lowLevelReset;
+exports.lowLevelSet = lowLevelSet;
+exports.lowLevelSetOptions = lowLevelSetOptions;
+exports.upgradeCacheMeta = upgradeCacheMeta;