limited-cache 2.2.0 → 2.3.1

package/dist/cjs/index.d.cts

@@ -1,92 +1,100 @@
+//#region src/types.d.ts
 type DefaultItemType = any;
 interface LimitedCacheOptionsFull {
-    /** Items will be removed to keep the cache within the maxCacheSize limit */
-    maxCacheSize: number;
-    /** Items will be removed and never returned if they were set more than maxCacheTime milliseconds ago */
-    maxCacheTime: number;
-    /** (dev only) A warning will be emitted if an item rotates out of the cache before this many milliseconds have passed, to indicate the size is too small */
-    warnIfItemPurgedBeforeTime: number;
-    /** (private) Internal cleanup of old keys will be performed after this many operations */
-    opLimit: number;
-    /** (private) Internal optimization to adjust how much searching will be done to find expired items, to avoid being O(n) */
-    scanLimit: number;
+  /** Items will be removed to keep the cache within the maxCacheSize limit */
+  maxCacheSize: number;
+  /** Items will be removed and never returned if they were set more than maxCacheTime milliseconds ago */
+  maxCacheTime: number;
+  /** (dev only) A warning will be emitted if an item rotates out of the cache before this many milliseconds have passed, to indicate the size is too small */
+  warnIfItemPurgedBeforeTime: number;
+  /** (private) Internal cleanup of old keys will be performed after this many operations */
+  opLimit: number;
+  /** (private) Internal optimization to adjust how much searching will be done to find expired items, to avoid being O(n) */
+  scanLimit: number;
 }
 type LimitedCacheOptions = Partial<LimitedCacheOptionsFull> | null;
 type LimitedCacheOptionsReadonly = Readonly<LimitedCacheOptionsFull>;
 interface LimitedCacheInstance<ItemType = DefaultItemType> {
-    /** Return the requested item, if it has not expired */
-    get: (cacheKey: string) => ItemType | undefined;
-    /** Return all non-expired items */
-    getAll: () => Record<string, ItemType>;
-    /** Indicate whether or not the requested item is present and has not expired */
-    has: (cacheKey: string) => boolean;
-    /** Add the item to the cache, or update its timestamp if it already exists */
-    set: (cacheKey: string, item: ItemType) => ItemType;
-    /** Remove the requested item from the cache, if necessary */
-    remove: (cacheKey: string) => true;
-    /** Remove all items and all timestamps from the cache */
-    reset: () => LimitedCacheMeta<ItemType>;
-    /** Return a serializable representation of the cache internals, suitable for long-term storage */
-    getCacheMeta: () => LimitedCacheMeta<ItemType>;
-    /** Return the cache's current values for all options */
-    getOptions: () => LimitedCacheOptionsFull;
-    /** Update one or more of the cache's options */
-    setOptions: (newOptions: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
-    /** Reduces cache size by cleaning up old keys and expired items */
-    doMaintenance: () => LimitedCacheMeta<ItemType>;
+  /** Return the requested item, if it has not expired */
+  get: (cacheKey: string) => ItemType | undefined;
+  /** Return all non-expired items */
+  getAll: () => Record<string, ItemType>;
+  /** Indicate whether or not the requested item is present and has not expired */
+  has: (cacheKey: string) => boolean;
+  /** Add the item to the cache, or update its timestamp if it already exists */
+  set: (cacheKey: string, item: ItemType) => ItemType;
+  /** Remove the requested item from the cache, if necessary */
+  remove: (cacheKey: string) => true;
+  /** Remove all items and all timestamps from the cache */
+  reset: () => LimitedCacheMeta<ItemType>;
+  /** Return a serializable representation of the cache internals, suitable for long-term storage */
+  getCacheMeta: () => LimitedCacheMeta<ItemType>;
+  /** Return the cache's current values for all options */
+  getOptions: () => LimitedCacheOptionsFull;
+  /** Update one or more of the cache's options */
+  setOptions: (newOptions: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
+  /** Reduces cache size by cleaning up old keys and expired items */
+  doMaintenance: () => LimitedCacheMeta<ItemType>;
 }
 interface LimitedCacheObjectInstance<ItemType = DefaultItemType> {
-    [key: string]: ItemType;
+  [key: string]: ItemType;
 }
 /**
- *  A serializable representation of the cache internals, suitable for long-term storage
- */
+*  A serializable representation of the cache internals, suitable for long-term storage
+*/
 interface LimitedCacheMeta<ItemType = DefaultItemType> {
-    /** Schema version: old versions will be upgraded if possible, or a warning will be emitted if not */
-    limitedCacheMetaVersion: number;
-    /** Options to control cache size, time, and behavior */
-    options: LimitedCacheOptionsReadonly;
-    /** The values in the cache, stored by key. Will include old keys not yet garbage collected */
-    cache: Record<string, ItemType | undefined>;
-    /** List of keys that have been set, in chronological order. Used to find cache items most likely to be expired */
-    keyList: Array<string>;
-    /** The [setTime, expirationTime] for each key that has been set. Removed on unset. */
-    keyInfo: Record<string, [number, number] | undefined>;
-    /** Number of operations remaining until internal cleanup of old keys is performed. Based on options.opLimit */
-    opsLeft: number;
+  /** Schema version: old versions will be upgraded if possible, or a warning will be emitted if not */
+  limitedCacheMetaVersion: number;
+  /** Options to control cache size, time, and behavior */
+  options: LimitedCacheOptionsReadonly;
+  /** The values in the cache, stored by key. Will include old keys not yet garbage collected */
+  cache: Record<string, ItemType | undefined>;
+  /** List of keys that have been set, in chronological order. Used to find cache items most likely to be expired */
+  keyList: Array<string>;
+  /** The [setTime, expirationTime] for each key that has been set. Removed on unset. */
+  keyInfo: Record<string, [number, number] | undefined>;
+  /** Number of operations remaining until internal cleanup of old keys is performed. Based on options.opLimit */
+  opsLeft: number;
 }
-
-declare const CURRENT_META_VERSION = 2;
+//#endregion
+//#region src/core/defaultOptions.d.ts
+declare const CURRENT_META_VERSION: 2;
 declare const MAXIMUM_CACHE_TIME: number;
 declare const defaultOptions: LimitedCacheOptionsReadonly;
-
-declare const LimitedCache: <ItemType = any>(options?: LimitedCacheOptions) => LimitedCacheInstance<ItemType>;
-
-declare const LimitedCacheObject: <ItemType = any>(options?: LimitedCacheOptions) => LimitedCacheObjectInstance<ItemType>;
+//#endregion
+//#region src/core/LimitedCache.d.ts
+declare const LimitedCache: <ItemType = DefaultItemType>(options?: LimitedCacheOptions) => LimitedCacheInstance<ItemType>;
+//#endregion
+//#region src/core/LimitedCacheObject.d.ts
+declare const LimitedCacheObject: <ItemType = DefaultItemType>(options?: LimitedCacheOptions) => LimitedCacheObjectInstance<ItemType>;
 declare const getCacheMetaFromObject: (instance: LimitedCacheObjectInstance) => LimitedCacheMeta;
-
-declare const limitedCacheUtil: {
-    init: <ItemType = any>(optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType> | undefined) => LimitedCacheMeta<ItemType>;
-    get: <ItemType_1 = any>(cacheMeta: LimitedCacheMeta<ItemType_1>, cacheKey: string) => ItemType_1 | undefined;
-    getAll: <ItemType_2 = any>(cacheMeta: LimitedCacheMeta<ItemType_2>) => Record<string, ItemType_2>;
-    has: <ItemType_3 = any>(cacheMeta: LimitedCacheMeta<ItemType_3>, cacheKey: string) => boolean;
-    set: <ItemType_4 = any>(cacheMeta: LimitedCacheMeta<ItemType_4>, cacheKey: string, item: ItemType_4) => LimitedCacheMeta<ItemType_4>;
-    remove: <ItemType_5 = any>(cacheMeta: LimitedCacheMeta<ItemType_5>, cacheKey: string) => LimitedCacheMeta<ItemType_5>;
-    reset: <ItemType_6 = any>(cacheMeta: LimitedCacheMeta<ItemType_6>) => LimitedCacheMeta<ItemType_6>;
-    doMaintenance: <ItemType_7 = any>(cacheMeta: LimitedCacheMeta<ItemType_7>) => LimitedCacheMeta<ItemType_7>;
-    setOptions: <ItemType_8 = any>(cacheMeta: LimitedCacheMeta<ItemType_8>, options: LimitedCacheOptions) => Readonly<LimitedCacheOptionsFull>;
-};
-
-declare const isCacheMeta: (cacheMeta: LimitedCacheMeta) => boolean;
+//#endregion
+//#region src/core/lowLevelFunctions.d.ts
+declare const isCacheMeta: (cacheMeta: unknown) => cacheMeta is LimitedCacheMeta;
 declare const upgradeCacheMeta: (cacheMeta: LimitedCacheMeta) => void;
-declare const lowLevelSetOptions: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, options: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
-declare const lowLevelInit: <ItemType = any>(optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType> | undefined) => LimitedCacheMeta<ItemType>;
-declare const lowLevelDoMaintenance: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
-declare const lowLevelHas: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => boolean;
-declare const lowLevelGetOne: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => ItemType | undefined;
-declare const lowLevelGetAll: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>) => Record<string, ItemType>;
-declare const lowLevelSet: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string, item: ItemType) => LimitedCacheMeta<ItemType>;
-declare const lowLevelRemove: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => LimitedCacheMeta<ItemType>;
-declare const lowLevelReset: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
-
-export { CURRENT_META_VERSION, type DefaultItemType, LimitedCache, type LimitedCacheInstance, type LimitedCacheMeta, LimitedCacheObject, type LimitedCacheObjectInstance, type LimitedCacheOptions, type LimitedCacheOptionsFull, type LimitedCacheOptionsReadonly, MAXIMUM_CACHE_TIME, defaultOptions, getCacheMetaFromObject, isCacheMeta, limitedCacheUtil, lowLevelDoMaintenance, lowLevelGetAll, lowLevelGetOne, lowLevelHas, lowLevelInit, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, upgradeCacheMeta };
+declare const lowLevelSetOptions: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, options: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
+declare const lowLevelInit: <ItemType = DefaultItemType>(optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
+declare const lowLevelDoMaintenance: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
+declare const lowLevelHas: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => boolean;
+declare const lowLevelGetOne: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => ItemType | undefined;
+declare const lowLevelGetAll: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>) => Record<string, ItemType>;
+declare const lowLevelSet: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string, item: ItemType) => LimitedCacheMeta<ItemType>;
+declare const lowLevelRemove: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => LimitedCacheMeta<ItemType>;
+declare const lowLevelReset: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
+//#endregion
+//#region src/core/limitedCacheUtil.d.ts
+type LimitedCacheUtil = {
+  init: typeof lowLevelInit;
+  get: typeof lowLevelGetOne;
+  getAll: typeof lowLevelGetAll;
+  has: typeof lowLevelHas;
+  set: typeof lowLevelSet;
+  remove: typeof lowLevelRemove;
+  reset: typeof lowLevelReset;
+  doMaintenance: typeof lowLevelDoMaintenance;
+  setOptions: typeof lowLevelSetOptions;
+};
+declare const limitedCacheUtil: LimitedCacheUtil;
+//#endregion
+export { CURRENT_META_VERSION, DefaultItemType, LimitedCache, LimitedCacheInstance, LimitedCacheMeta, LimitedCacheObject, LimitedCacheObjectInstance, LimitedCacheOptions, LimitedCacheOptionsFull, LimitedCacheOptionsReadonly, MAXIMUM_CACHE_TIME, defaultOptions, getCacheMetaFromObject, isCacheMeta, limitedCacheUtil, lowLevelDoMaintenance, lowLevelGetAll, lowLevelGetOne, lowLevelHas, lowLevelInit, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, upgradeCacheMeta };
+//# sourceMappingURL=index.d.cts.map

package/dist/cjs/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/types.ts","../../src/core/defaultOptions.ts","../../src/core/LimitedCache.ts","../../src/core/LimitedCacheObject.ts","../../src/core/lowLevelFunctions.ts","../../src/core/limitedCacheUtil.ts"],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -1,7 +1,100 @@
-export * from './core/defaultOptions.js';
-export * from './core/LimitedCache.js';
-export * from './core/LimitedCacheObject.js';
-export * from './core/limitedCacheUtil.js';
-export * from './core/lowLevelFunctions.js';
-export * from './types.js';
+//#region src/types.d.ts
+type DefaultItemType = any;
+interface LimitedCacheOptionsFull {
+  /** Items will be removed to keep the cache within the maxCacheSize limit */
+  maxCacheSize: number;
+  /** Items will be removed and never returned if they were set more than maxCacheTime milliseconds ago */
+  maxCacheTime: number;
+  /** (dev only) A warning will be emitted if an item rotates out of the cache before this many milliseconds have passed, to indicate the size is too small */
+  warnIfItemPurgedBeforeTime: number;
+  /** (private) Internal cleanup of old keys will be performed after this many operations */
+  opLimit: number;
+  /** (private) Internal optimization to adjust how much searching will be done to find expired items, to avoid being O(n) */
+  scanLimit: number;
+}
+type LimitedCacheOptions = Partial<LimitedCacheOptionsFull> | null;
+type LimitedCacheOptionsReadonly = Readonly<LimitedCacheOptionsFull>;
+interface LimitedCacheInstance<ItemType = DefaultItemType> {
+  /** Return the requested item, if it has not expired */
+  get: (cacheKey: string) => ItemType | undefined;
+  /** Return all non-expired items */
+  getAll: () => Record<string, ItemType>;
+  /** Indicate whether or not the requested item is present and has not expired */
+  has: (cacheKey: string) => boolean;
+  /** Add the item to the cache, or update its timestamp if it already exists */
+  set: (cacheKey: string, item: ItemType) => ItemType;
+  /** Remove the requested item from the cache, if necessary */
+  remove: (cacheKey: string) => true;
+  /** Remove all items and all timestamps from the cache */
+  reset: () => LimitedCacheMeta<ItemType>;
+  /** Return a serializable representation of the cache internals, suitable for long-term storage */
+  getCacheMeta: () => LimitedCacheMeta<ItemType>;
+  /** Return the cache's current values for all options */
+  getOptions: () => LimitedCacheOptionsFull;
+  /** Update one or more of the cache's options */
+  setOptions: (newOptions: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
+  /** Reduces cache size by cleaning up old keys and expired items */
+  doMaintenance: () => LimitedCacheMeta<ItemType>;
+}
+interface LimitedCacheObjectInstance<ItemType = DefaultItemType> {
+  [key: string]: ItemType;
+}
+/**
+*  A serializable representation of the cache internals, suitable for long-term storage
+*/
+interface LimitedCacheMeta<ItemType = DefaultItemType> {
+  /** Schema version: old versions will be upgraded if possible, or a warning will be emitted if not */
+  limitedCacheMetaVersion: number;
+  /** Options to control cache size, time, and behavior */
+  options: LimitedCacheOptionsReadonly;
+  /** The values in the cache, stored by key. Will include old keys not yet garbage collected */
+  cache: Record<string, ItemType | undefined>;
+  /** List of keys that have been set, in chronological order. Used to find cache items most likely to be expired */
+  keyList: Array<string>;
+  /** The [setTime, expirationTime] for each key that has been set. Removed on unset. */
+  keyInfo: Record<string, [number, number] | undefined>;
+  /** Number of operations remaining until internal cleanup of old keys is performed. Based on options.opLimit */
+  opsLeft: number;
+}
+//#endregion
+//#region src/core/defaultOptions.d.ts
+declare const CURRENT_META_VERSION: 2;
+declare const MAXIMUM_CACHE_TIME: number;
+declare const defaultOptions: LimitedCacheOptionsReadonly;
+//#endregion
+//#region src/core/LimitedCache.d.ts
+declare const LimitedCache: <ItemType = DefaultItemType>(options?: LimitedCacheOptions) => LimitedCacheInstance<ItemType>;
+//#endregion
+//#region src/core/LimitedCacheObject.d.ts
+declare const LimitedCacheObject: <ItemType = DefaultItemType>(options?: LimitedCacheOptions) => LimitedCacheObjectInstance<ItemType>;
+declare const getCacheMetaFromObject: (instance: LimitedCacheObjectInstance) => LimitedCacheMeta;
+//#endregion
+//#region src/core/lowLevelFunctions.d.ts
+declare const isCacheMeta: (cacheMeta: unknown) => cacheMeta is LimitedCacheMeta;
+declare const upgradeCacheMeta: (cacheMeta: LimitedCacheMeta) => void;
+declare const lowLevelSetOptions: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, options: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
+declare const lowLevelInit: <ItemType = DefaultItemType>(optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
+declare const lowLevelDoMaintenance: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
+declare const lowLevelHas: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => boolean;
+declare const lowLevelGetOne: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => ItemType | undefined;
+declare const lowLevelGetAll: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>) => Record<string, ItemType>;
+declare const lowLevelSet: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string, item: ItemType) => LimitedCacheMeta<ItemType>;
+declare const lowLevelRemove: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => LimitedCacheMeta<ItemType>;
+declare const lowLevelReset: <ItemType = DefaultItemType>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
+//#endregion
+//#region src/core/limitedCacheUtil.d.ts
+type LimitedCacheUtil = {
+  init: typeof lowLevelInit;
+  get: typeof lowLevelGetOne;
+  getAll: typeof lowLevelGetAll;
+  has: typeof lowLevelHas;
+  set: typeof lowLevelSet;
+  remove: typeof lowLevelRemove;
+  reset: typeof lowLevelReset;
+  doMaintenance: typeof lowLevelDoMaintenance;
+  setOptions: typeof lowLevelSetOptions;
+};
+declare const limitedCacheUtil: LimitedCacheUtil;
+//#endregion
+export { CURRENT_META_VERSION, DefaultItemType, LimitedCache, LimitedCacheInstance, LimitedCacheMeta, LimitedCacheObject, LimitedCacheObjectInstance, LimitedCacheOptions, LimitedCacheOptionsFull, LimitedCacheOptionsReadonly, MAXIMUM_CACHE_TIME, defaultOptions, getCacheMetaFromObject, isCacheMeta, limitedCacheUtil, lowLevelDoMaintenance, lowLevelGetAll, lowLevelGetOne, lowLevelHas, lowLevelInit, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, upgradeCacheMeta };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAE3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/types.ts","../../src/core/defaultOptions.ts","../../src/core/LimitedCache.ts","../../src/core/LimitedCacheObject.ts","../../src/core/lowLevelFunctions.ts","../../src/core/limitedCacheUtil.ts"],"mappings":"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"}

package/dist/esm/index.js

@@ -1,7 +1,280 @@
-export * from './core/defaultOptions.js';
-export * from './core/LimitedCache.js';
-export * from './core/LimitedCacheObject.js';
-export * from './core/limitedCacheUtil.js';
-export * from './core/lowLevelFunctions.js';
-export * from './types.js';
+//#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
+};
+//#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;
+};
+const isCacheMeta = (cacheMeta) => {
+	return !!cacheMeta?.limitedCacheMetaVersion;
+};
+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);
+	}
+};
+const lowLevelSetOptions = (cacheMeta, options) => {
+	upgradeCacheMeta(cacheMeta);
+	return normalizeOptions(Object.assign(cacheMeta.options, options));
+};
+const lowLevelInit = (optionsOrCacheMeta) => {
+	if (isCacheMeta(optionsOrCacheMeta)) {
+		const existingCacheMeta = optionsOrCacheMeta;
+		upgradeCacheMeta(existingCacheMeta);
+		return existingCacheMeta;
+	}
+	return lowLevelReset({
+		limitedCacheMetaVersion: 2,
+		options: normalizeOptions({
+			...defaultOptions,
+			...optionsOrCacheMeta
+		})
+	});
+};
+const _getExpireTime = (cacheMeta, cacheKey) => {
+	const { options: { maxCacheTime }, keyInfo: { [cacheKey]: keyInfo } } = cacheMeta;
+	if (!keyInfo) return 0;
+	const [setTime, expireTime] = keyInfo;
+	return expireTime || setTime + (maxCacheTime || 31536e6);
+};
+const _cacheKeyHasExpired = (cacheMeta, cacheKey, now) => {
+	return _getExpireTime(cacheMeta, cacheKey) < now;
+};
+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
+	});
+};
+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);
+};
+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);
+};
+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;
+};
+const lowLevelGetOne = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	if (lowLevelHas(cacheMeta, cacheKey)) return cacheMeta.cache[cacheKey];
+};
+const lowLevelGetAll = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	lowLevelDoMaintenance(cacheMeta);
+	return cacheMeta.cache;
+};
+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;
+};
+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;
+};
+const lowLevelReset = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	return Object.assign(cacheMeta, {
+		cache: {},
+		keyList: [],
+		keyInfo: Object.create(null),
+		opsLeft: cacheMeta.options.opLimit
+	});
+};
+//#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)
+	};
+};
+//#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))
+};
+/**
+* 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);
+};
+/**
+* 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;
+};
+const getCacheMetaFromObject = (instance) => {
+	return cacheMetasForProxies.get(instance);
+};
+//#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
+};
+//#endregion
+export { CURRENT_META_VERSION, LimitedCache, LimitedCacheObject, MAXIMUM_CACHE_TIME, defaultOptions, getCacheMetaFromObject, isCacheMeta, limitedCacheUtil, lowLevelDoMaintenance, lowLevelGetAll, lowLevelGetOne, lowLevelHas, lowLevelInit, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, upgradeCacheMeta };
+
 //# sourceMappingURL=index.js.map