@stryke/helpers 0.9.35 → 0.9.36

package/dist/is-equal.mjs

@@ -1,2 +1,88 @@
-import{isSet as e}from"./type-checks/src/is-set.mjs";import{isSetString as t}from"./type-checks/src/is-set-string.mjs";const n=typeof Map==`function`,r=typeof Set==`function`,i=typeof ArrayBuffer==`function`&&ArrayBuffer.isView!==void 0;function a(o,s){if(o===s)return!0;if(o&&s&&typeof o==`object`&&typeof s==`object`){if(o.constructor!==s.constructor)return!1;let c;if(Array.isArray(o)){if(c=o.length,c!=s.length)return!1;for(let e=c;e--!==0;)if(!a(o[e],s[e]))return!1;return!0}let l;if(n&&o instanceof Map&&s instanceof Map){if(o.size!==s.size)return!1;l=o.entries();let e;for(;!(e=l.next()).done;)if(!s.has(e.value[0]))return!1;for(l=o.entries();!(e=l.next()).done;)if(!a(e.value[1],s.get(e.value[0])))return!1;return!0}if(r&&o instanceof Set&&s instanceof Set){if(o.size!==s.size)return!1;l=o.entries();let e;for(;!(e=l.next()).done;)if(!s.has(e.value[0]))return!1;return!0}if(Array.isArray(o)&&Array.isArray(s)&&i&&ArrayBuffer.isView(o)&&ArrayBuffer.isView(s)){if(c=o.length,c!=s.length)return!1;for(let e=c;e--!==0;)if(o[e]!==s[e])return!1;return!0}if(o.constructor===RegExp)return o.source===s.source&&o.flags===s.flags;if(o.valueOf!==Object.prototype.valueOf&&typeof o.valueOf==`function`&&typeof s.valueOf==`function`)return o.valueOf()===s.valueOf();if(o.toString!==Object.prototype.toString&&typeof o.toString==`function`&&typeof s.toString==`function`)return o.toString()===s.toString();let u=Object.keys(o);if(c=u.length,c!==Object.keys(s).length)return!1;for(let n=c;n--!==0;)if(!e(n)||!t(u[n])||!Object.prototype.hasOwnProperty.call(s,u[n]))return!1;for(let n=c;n--!==0;)if(!(Array.isArray(u)&&(u[n]===`_owner`||u[n]===`__v`||u[n]===`__o`)&&o.$$typeof)&&(!e(n)||!t(u[n])||!a(o[u[n]],s[u[n]])))return!1;return!0}return o!==o&&s!==s}function o(e,t){try{return a(e,t)}catch(e){if(/stack|recursion/i.test(e?.message||``))return console.warn(`isEqual cannot handle circular refs`),!1;throw e}}export{o as isEqual};
+import { isSet } from "./type-checks/src/is-set.mjs";
+import { isSetString } from "./type-checks/src/is-set-string.mjs";
+
+//#region src/is-equal.ts
+const hasMap = typeof Map === "function";
+const hasSet = typeof Set === "function";
+const hasArrayBuffer = typeof ArrayBuffer === "function" && ArrayBuffer.isView !== void 0;
+function equal(a, b) {
+	if (a === b) return true;
+	if (a && b && typeof a === "object" && typeof b === "object") {
+		if (a.constructor !== b.constructor) return false;
+		let length;
+		if (Array.isArray(a)) {
+			length = a.length;
+			if (length != b.length) return false;
+			for (let i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
+			return true;
+		}
+		let it;
+		if (hasMap && a instanceof Map && b instanceof Map) {
+			if (a.size !== b.size) return false;
+			it = a.entries();
+			let i;
+			while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;
+			it = a.entries();
+			while (!(i = it.next()).done) if (!equal(i.value[1], b.get(i.value[0]))) return false;
+			return true;
+		}
+		if (hasSet && a instanceof Set && b instanceof Set) {
+			if (a.size !== b.size) return false;
+			it = a.entries();
+			let i;
+			while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;
+			return true;
+		}
+		if (Array.isArray(a) && Array.isArray(b) && hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+			length = a.length;
+			if (length != b.length) return false;
+			for (let i = length; i-- !== 0;) if (a[i] !== b[i]) return false;
+			return true;
+		}
+		if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+		if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === "function" && typeof b.valueOf === "function") return a.valueOf() === b.valueOf();
+		if (a.toString !== Object.prototype.toString && typeof a.toString === "function" && typeof b.toString === "function") return a.toString() === b.toString();
+		const keys = Object.keys(a);
+		length = keys.length;
+		if (length !== Object.keys(b).length) return false;
+		for (let i = length; i-- !== 0;) if (!isSet(i) || !isSetString(keys[i]) || !Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+		for (let i = length; i-- !== 0;) {
+			if (Array.isArray(keys) && (keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) continue;
+			if (!isSet(i) || !isSetString(keys[i]) || !equal(a[keys[i]], b[keys[i]])) return false;
+		}
+		return true;
+	}
+	return a !== a && b !== b;
+}
+/**
+* Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
+*
+* @example
+* ```ts
+* isEqual(1, 1); // true
+* isEqual({ a: 1 }, { a: 1 }); // true
+* isEqual(/abc/g, /abc/g); // true
+* isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
+* isEqual([1, 2, 3], [1, 2, 3]); // true
+* isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true
+* ```
+*
+* @param a - The first value to compare.
+* @param b - The second value to compare.
+* @returns `true` if the values are equal, otherwise `false`.
+*/
+function isEqual(a, b) {
+	try {
+		return equal(a, b);
+	} catch (error) {
+		if (/stack|recursion/i.test(error?.message || "")) {
+			console.warn("isEqual cannot handle circular refs");
+			return false;
+		}
+		throw error;
+	}
+}
+
+//#endregion
+export { isEqual };
 //# sourceMappingURL=is-equal.mjs.map

package/dist/is-equal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-equal.mjs","names":[],"sources":["../src/is-equal.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { isSet } from \"@stryke/type-checks/is-set\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\n\nconst hasMap = typeof Map === \"function\";\nconst hasSet = typeof Set === \"function\";\nconst hasArrayBuffer =\n  typeof ArrayBuffer === \"function\" && ArrayBuffer.isView !== undefined;\n\nfunction equal(a: any, b: any) {\n  if (a === b) {\n    return true;\n  }\n\n  if (a && b && typeof a === \"object\" && typeof b === \"object\") {\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    let length;\n    if (Array.isArray(a)) {\n      length = a.length;\n\n      if (length != b.length) return false;\n      for (let i = length; i-- !== 0; ) if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    let it;\n    if (hasMap && a instanceof Map && b instanceof Map) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      let i;\n      while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;\n      it = a.entries();\n      while (!(i = it.next()).done) {\n        if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      }\n      return true;\n    }\n\n    if (hasSet && a instanceof Set && b instanceof Set) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      let i;\n      while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;\n      return true;\n    }\n\n    if (\n      Array.isArray(a) &&\n      Array.isArray(b) &&\n      hasArrayBuffer &&\n      ArrayBuffer.isView(a) &&\n      ArrayBuffer.isView(b)\n    ) {\n      length = a.length;\n\n      if (length != b.length) return false;\n      for (let i = length; i-- !== 0; ) if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n    if (a.constructor === RegExp) {\n      return a.source === b.source && a.flags === b.flags;\n    }\n\n    if (\n      a.valueOf !== Object.prototype.valueOf &&\n      typeof a.valueOf === \"function\" &&\n      typeof b.valueOf === \"function\"\n    ) {\n      // eslint-disable-next-line ts/no-unsafe-call\n      return a.valueOf() === b.valueOf();\n    }\n    if (\n      a.toString !== Object.prototype.toString &&\n      typeof a.toString === \"function\" &&\n      typeof b.toString === \"function\"\n    ) {\n      // eslint-disable-next-line ts/no-unsafe-call\n      return a.toString() === b.toString();\n    }\n\n    const keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n\n    for (let i = length; i-- !== 0; ) {\n      if (\n        !isSet(i) ||\n        !isSetString(keys[i]) ||\n        !Object.prototype.hasOwnProperty.call(b, keys[i] as any)\n      ) {\n        return false;\n      }\n    }\n\n    for (let i = length; i-- !== 0; ) {\n      if (\n        Array.isArray(keys) &&\n        (keys[i] === \"_owner\" || keys[i] === \"__v\" || keys[i] === \"__o\") &&\n        a.$$typeof\n      ) {\n        continue;\n      }\n\n      if (\n        !isSet(i) ||\n        !isSetString(keys[i]) ||\n        !equal(a[keys[i] as any], b[keys[i] as any])\n      ) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  // eslint-disable-next-line no-self-compare\n  return a !== a && b !== b;\n}\n\n/**\n * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.\n *\n * @example\n * ```ts\n * isEqual(1, 1); // true\n * isEqual({ a: 1 }, { a: 1 }); // true\n * isEqual(/abc/g, /abc/g); // true\n * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true\n * isEqual([1, 2, 3], [1, 2, 3]); // true\n * isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true\n * ```\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @returns `true` if the values are equal, otherwise `false`.\n */\nexport function isEqual(a: any, b: any): boolean {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if (/stack|recursion/i.test((error as any)?.message || \"\")) {\n      // eslint-disable-next-line no-console\n      console.warn(\"isEqual cannot handle circular refs\");\n\n      return false;\n    }\n\n    throw error;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"is-equal.mjs","names":[],"sources":["../src/is-equal.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { isSet } from \"@stryke/type-checks/is-set\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\n\nconst hasMap = typeof Map === \"function\";\nconst hasSet = typeof Set === \"function\";\nconst hasArrayBuffer =\n  typeof ArrayBuffer === \"function\" && ArrayBuffer.isView !== undefined;\n\nfunction equal(a: any, b: any) {\n  if (a === b) {\n    return true;\n  }\n\n  if (a && b && typeof a === \"object\" && typeof b === \"object\") {\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    let length;\n    if (Array.isArray(a)) {\n      length = a.length;\n\n      if (length != b.length) return false;\n      for (let i = length; i-- !== 0; ) if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    let it;\n    if (hasMap && a instanceof Map && b instanceof Map) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      let i;\n      while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;\n      it = a.entries();\n      while (!(i = it.next()).done) {\n        if (!equal(i.value[1], b.get(i.value[0]))) return false;\n      }\n      return true;\n    }\n\n    if (hasSet && a instanceof Set && b instanceof Set) {\n      if (a.size !== b.size) return false;\n      it = a.entries();\n      let i;\n      while (!(i = it.next()).done) if (!b.has(i.value[0])) return false;\n      return true;\n    }\n\n    if (\n      Array.isArray(a) &&\n      Array.isArray(b) &&\n      hasArrayBuffer &&\n      ArrayBuffer.isView(a) &&\n      ArrayBuffer.isView(b)\n    ) {\n      length = a.length;\n\n      if (length != b.length) return false;\n      for (let i = length; i-- !== 0; ) if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n    if (a.constructor === RegExp) {\n      return a.source === b.source && a.flags === b.flags;\n    }\n\n    if (\n      a.valueOf !== Object.prototype.valueOf &&\n      typeof a.valueOf === \"function\" &&\n      typeof b.valueOf === \"function\"\n    ) {\n      // eslint-disable-next-line ts/no-unsafe-call\n      return a.valueOf() === b.valueOf();\n    }\n    if (\n      a.toString !== Object.prototype.toString &&\n      typeof a.toString === \"function\" &&\n      typeof b.toString === \"function\"\n    ) {\n      // eslint-disable-next-line ts/no-unsafe-call\n      return a.toString() === b.toString();\n    }\n\n    const keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) {\n      return false;\n    }\n\n    for (let i = length; i-- !== 0; ) {\n      if (\n        !isSet(i) ||\n        !isSetString(keys[i]) ||\n        !Object.prototype.hasOwnProperty.call(b, keys[i] as any)\n      ) {\n        return false;\n      }\n    }\n\n    for (let i = length; i-- !== 0; ) {\n      if (\n        Array.isArray(keys) &&\n        (keys[i] === \"_owner\" || keys[i] === \"__v\" || keys[i] === \"__o\") &&\n        a.$$typeof\n      ) {\n        continue;\n      }\n\n      if (\n        !isSet(i) ||\n        !isSetString(keys[i]) ||\n        !equal(a[keys[i] as any], b[keys[i] as any])\n      ) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  // eslint-disable-next-line no-self-compare\n  return a !== a && b !== b;\n}\n\n/**\n * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.\n *\n * @example\n * ```ts\n * isEqual(1, 1); // true\n * isEqual({ a: 1 }, { a: 1 }); // true\n * isEqual(/abc/g, /abc/g); // true\n * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true\n * isEqual([1, 2, 3], [1, 2, 3]); // true\n * isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true\n * ```\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n * @returns `true` if the values are equal, otherwise `false`.\n */\nexport function isEqual(a: any, b: any): boolean {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if (/stack|recursion/i.test((error as any)?.message || \"\")) {\n      // eslint-disable-next-line no-console\n      console.warn(\"isEqual cannot handle circular refs\");\n\n      return false;\n    }\n\n    throw error;\n  }\n}\n"],"mappings":"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"}

package/dist/lru-cache.cjs

@@ -1 +1,190 @@
-var e=class{key;data;size;prev=null;next=null;constructor(e,t,n){this.key=e,this.data=t,this.size=n}},t=class{prev=null;next=null},n=class{cache=new Map;head;tail;totalSize=0;maxSize;calculateSize;constructor(e,n){this.maxSize=e,this.calculateSize=n,this.head=new t,this.tail=new t,this.head.next=this.tail,this.tail.prev=this.head}addToHead(e){e.prev=this.head,e.next=this.head.next,this.head.next.prev=e,this.head.next=e}removeNode(e){e.prev.next=e.next,e.next.prev=e.prev}moveToHead(e){this.removeNode(e),this.addToHead(e)}removeTail(){let e=this.tail.prev;return this.removeNode(e),e}set(t,n){let r=this.calculateSize?.(n)??1;if(r>this.maxSize)return;let i=this.cache.get(t);if(i)i.data=n,this.totalSize=this.totalSize-i.size+r,i.size=r,this.moveToHead(i);else{let i=new e(t,n,r);this.cache.set(t,i),this.addToHead(i),this.totalSize+=r}for(;this.totalSize>this.maxSize&&this.cache.size>0;){let e=this.removeTail();this.cache.delete(e.key),this.totalSize-=e.size}}has(e){return this.cache.has(e)}get(e){let t=this.cache.get(e);if(t)return this.moveToHead(t),t.data}*[Symbol.iterator](){let e=this.head.next;for(;e&&e!==this.tail;){let t=e;yield[t.key,t.data],e=e.next}}remove(e){let t=this.cache.get(e);t&&(this.removeNode(t),this.cache.delete(e),this.totalSize-=t.size)}get size(){return this.cache.size}get currentSize(){return this.totalSize}};exports.LRUCache=n;
+
+//#region src/lru-cache.ts
+var LRUNode = class {
+	key;
+	data;
+	size;
+	prev = null;
+	next = null;
+	constructor(key, data, size) {
+		this.key = key;
+		this.data = data;
+		this.size = size;
+	}
+};
+/**
+* Sentinel node used for head/tail boundaries.
+* These nodes don't contain actual cache data but simplify list operations.
+*/
+var SentinelNode = class {
+	prev = null;
+	next = null;
+};
+/**
+* LRU (Least Recently Used) Cache implementation using a doubly-linked list
+* and hash map for O(1) operations.
+*
+* Algorithm:
+* - Uses a doubly-linked list to maintain access order (most recent at head)
+* - Hash map provides O(1) key-to-node lookup
+* - Sentinel head/tail nodes simplify edge case handling
+* - Size-based eviction supports custom size calculation functions
+*
+* Data Structure Layout:
+* HEAD \<-\> [most recent] \<-\> ... \<-\> [least recent] \<-\> TAIL
+*
+* Operations:
+* - get(): Move accessed node to head (mark as most recent)
+* - set(): Add new node at head, evict from tail if over capacity
+* - Eviction: Remove least recent node (tail.prev) when size exceeds limit
+*/
+var LRUCache = class {
+	cache = /* @__PURE__ */ new Map();
+	head;
+	tail;
+	totalSize = 0;
+	maxSize;
+	calculateSize;
+	constructor(maxSize, calculateSize) {
+		this.maxSize = maxSize;
+		this.calculateSize = calculateSize;
+		this.head = new SentinelNode();
+		this.tail = new SentinelNode();
+		this.head.next = this.tail;
+		this.tail.prev = this.head;
+	}
+	/**
+	* Adds a node immediately after the head (marks as most recently used). Used when inserting new items or when an item is accessed. **PRECONDITION:** node must be disconnected (prev/next should be null)
+	*
+	* @param node - The node to add after the head.
+	*/
+	addToHead(node) {
+		node.prev = this.head;
+		node.next = this.head.next;
+		this.head.next.prev = node;
+		this.head.next = node;
+	}
+	/**
+	* Removes a node from its current position in the doubly-linked list. Updates the prev/next pointers of adjacent nodes to maintain list integrity. **PRECONDITION:** node must be connected (prev/next are non-null)
+	*
+	* @param node - The node to remove from the list.
+	*/
+	removeNode(node) {
+		node.prev.next = node.next;
+		node.next.prev = node.prev;
+	}
+	/**
+	* Moves an existing node to the head position (marks as most recently used). This is the core LRU operation - accessed items become most recent.
+	*
+	* @param node - The node to move to the head.
+	*/
+	moveToHead(node) {
+		this.removeNode(node);
+		this.addToHead(node);
+	}
+	/**
+	* Removes and returns the least recently used node (the one before tail). This is called during eviction when the cache exceeds capacity. **PRECONDITION:** cache is not empty (ensured by caller)
+	*
+	* @returns The removed least recently used node.
+	*/
+	removeTail() {
+		const lastNode = this.tail.prev;
+		this.removeNode(lastNode);
+		return lastNode;
+	}
+	/**
+	* Sets a key-value pair in the cache.
+	* If the key exists, updates the value and moves to head.
+	* If new, adds at head and evicts from tail if necessary.
+	*
+	* Time Complexity:
+	* - O(1) for uniform item sizes
+	* - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
+	*
+	* @param key - The key to set.
+	* @param value - The value to set.
+	*/
+	set(key, value) {
+		const size = this.calculateSize?.(value) ?? 1;
+		if (size > this.maxSize) return;
+		const existing = this.cache.get(key);
+		if (existing) {
+			existing.data = value;
+			this.totalSize = this.totalSize - existing.size + size;
+			existing.size = size;
+			this.moveToHead(existing);
+		} else {
+			const newNode = new LRUNode(key, value, size);
+			this.cache.set(key, newNode);
+			this.addToHead(newNode);
+			this.totalSize += size;
+		}
+		while (this.totalSize > this.maxSize && this.cache.size > 0) {
+			const tail = this.removeTail();
+			this.cache.delete(tail.key);
+			this.totalSize -= tail.size;
+		}
+	}
+	/**
+	* Checks if a key exists in the cache.
+	* This is a pure query operation - does NOT update LRU order.
+	*
+	* Time Complexity: O(1)
+	*/
+	has(key) {
+		return this.cache.has(key);
+	}
+	/**
+	* Retrieves a value by key and marks it as most recently used.
+	* Moving to head maintains the LRU property for future evictions.
+	*
+	* Time Complexity: O(1)
+	*/
+	get(key) {
+		const node = this.cache.get(key);
+		if (!node) return void 0;
+		this.moveToHead(node);
+		return node.data;
+	}
+	/**
+	* Returns an iterator over the cache entries. The order is outputted in the
+	* order of most recently used to least recently used.
+	*/
+	*[Symbol.iterator]() {
+		let current = this.head.next;
+		while (current && current !== this.tail) {
+			const node = current;
+			yield [node.key, node.data];
+			current = current.next;
+		}
+	}
+	/**
+	* Removes a specific key from the cache.
+	* Updates both the hash map and doubly-linked list.
+	*
+	* Time Complexity: O(1)
+	*/
+	remove(key) {
+		const node = this.cache.get(key);
+		if (!node) return;
+		this.removeNode(node);
+		this.cache.delete(key);
+		this.totalSize -= node.size;
+	}
+	/**
+	* Returns the number of items in the cache.
+	*/
+	get size() {
+		return this.cache.size;
+	}
+	/**
+	* Returns the current total size of all cached items.
+	* This uses the custom size calculation if provided.
+	*/
+	get currentSize() {
+		return this.totalSize;
+	}
+};
+
+//#endregion
+exports.LRUCache = LRUCache;

package/dist/lru-cache.mjs

@@ -1,2 +1,190 @@
-var e=class{key;data;size;prev=null;next=null;constructor(e,t,n){this.key=e,this.data=t,this.size=n}},t=class{prev=null;next=null},n=class{cache=new Map;head;tail;totalSize=0;maxSize;calculateSize;constructor(e,n){this.maxSize=e,this.calculateSize=n,this.head=new t,this.tail=new t,this.head.next=this.tail,this.tail.prev=this.head}addToHead(e){e.prev=this.head,e.next=this.head.next,this.head.next.prev=e,this.head.next=e}removeNode(e){e.prev.next=e.next,e.next.prev=e.prev}moveToHead(e){this.removeNode(e),this.addToHead(e)}removeTail(){let e=this.tail.prev;return this.removeNode(e),e}set(t,n){let r=this.calculateSize?.(n)??1;if(r>this.maxSize)return;let i=this.cache.get(t);if(i)i.data=n,this.totalSize=this.totalSize-i.size+r,i.size=r,this.moveToHead(i);else{let i=new e(t,n,r);this.cache.set(t,i),this.addToHead(i),this.totalSize+=r}for(;this.totalSize>this.maxSize&&this.cache.size>0;){let e=this.removeTail();this.cache.delete(e.key),this.totalSize-=e.size}}has(e){return this.cache.has(e)}get(e){let t=this.cache.get(e);if(t)return this.moveToHead(t),t.data}*[Symbol.iterator](){let e=this.head.next;for(;e&&e!==this.tail;){let t=e;yield[t.key,t.data],e=e.next}}remove(e){let t=this.cache.get(e);t&&(this.removeNode(t),this.cache.delete(e),this.totalSize-=t.size)}get size(){return this.cache.size}get currentSize(){return this.totalSize}};export{n as LRUCache};
+//#region src/lru-cache.ts
+var LRUNode = class {
+	key;
+	data;
+	size;
+	prev = null;
+	next = null;
+	constructor(key, data, size) {
+		this.key = key;
+		this.data = data;
+		this.size = size;
+	}
+};
+/**
+* Sentinel node used for head/tail boundaries.
+* These nodes don't contain actual cache data but simplify list operations.
+*/
+var SentinelNode = class {
+	prev = null;
+	next = null;
+};
+/**
+* LRU (Least Recently Used) Cache implementation using a doubly-linked list
+* and hash map for O(1) operations.
+*
+* Algorithm:
+* - Uses a doubly-linked list to maintain access order (most recent at head)
+* - Hash map provides O(1) key-to-node lookup
+* - Sentinel head/tail nodes simplify edge case handling
+* - Size-based eviction supports custom size calculation functions
+*
+* Data Structure Layout:
+* HEAD \<-\> [most recent] \<-\> ... \<-\> [least recent] \<-\> TAIL
+*
+* Operations:
+* - get(): Move accessed node to head (mark as most recent)
+* - set(): Add new node at head, evict from tail if over capacity
+* - Eviction: Remove least recent node (tail.prev) when size exceeds limit
+*/
+var LRUCache = class {
+	cache = /* @__PURE__ */ new Map();
+	head;
+	tail;
+	totalSize = 0;
+	maxSize;
+	calculateSize;
+	constructor(maxSize, calculateSize) {
+		this.maxSize = maxSize;
+		this.calculateSize = calculateSize;
+		this.head = new SentinelNode();
+		this.tail = new SentinelNode();
+		this.head.next = this.tail;
+		this.tail.prev = this.head;
+	}
+	/**
+	* Adds a node immediately after the head (marks as most recently used). Used when inserting new items or when an item is accessed. **PRECONDITION:** node must be disconnected (prev/next should be null)
+	*
+	* @param node - The node to add after the head.
+	*/
+	addToHead(node) {
+		node.prev = this.head;
+		node.next = this.head.next;
+		this.head.next.prev = node;
+		this.head.next = node;
+	}
+	/**
+	* Removes a node from its current position in the doubly-linked list. Updates the prev/next pointers of adjacent nodes to maintain list integrity. **PRECONDITION:** node must be connected (prev/next are non-null)
+	*
+	* @param node - The node to remove from the list.
+	*/
+	removeNode(node) {
+		node.prev.next = node.next;
+		node.next.prev = node.prev;
+	}
+	/**
+	* Moves an existing node to the head position (marks as most recently used). This is the core LRU operation - accessed items become most recent.
+	*
+	* @param node - The node to move to the head.
+	*/
+	moveToHead(node) {
+		this.removeNode(node);
+		this.addToHead(node);
+	}
+	/**
+	* Removes and returns the least recently used node (the one before tail). This is called during eviction when the cache exceeds capacity. **PRECONDITION:** cache is not empty (ensured by caller)
+	*
+	* @returns The removed least recently used node.
+	*/
+	removeTail() {
+		const lastNode = this.tail.prev;
+		this.removeNode(lastNode);
+		return lastNode;
+	}
+	/**
+	* Sets a key-value pair in the cache.
+	* If the key exists, updates the value and moves to head.
+	* If new, adds at head and evicts from tail if necessary.
+	*
+	* Time Complexity:
+	* - O(1) for uniform item sizes
+	* - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
+	*
+	* @param key - The key to set.
+	* @param value - The value to set.
+	*/
+	set(key, value) {
+		const size = this.calculateSize?.(value) ?? 1;
+		if (size > this.maxSize) return;
+		const existing = this.cache.get(key);
+		if (existing) {
+			existing.data = value;
+			this.totalSize = this.totalSize - existing.size + size;
+			existing.size = size;
+			this.moveToHead(existing);
+		} else {
+			const newNode = new LRUNode(key, value, size);
+			this.cache.set(key, newNode);
+			this.addToHead(newNode);
+			this.totalSize += size;
+		}
+		while (this.totalSize > this.maxSize && this.cache.size > 0) {
+			const tail = this.removeTail();
+			this.cache.delete(tail.key);
+			this.totalSize -= tail.size;
+		}
+	}
+	/**
+	* Checks if a key exists in the cache.
+	* This is a pure query operation - does NOT update LRU order.
+	*
+	* Time Complexity: O(1)
+	*/
+	has(key) {
+		return this.cache.has(key);
+	}
+	/**
+	* Retrieves a value by key and marks it as most recently used.
+	* Moving to head maintains the LRU property for future evictions.
+	*
+	* Time Complexity: O(1)
+	*/
+	get(key) {
+		const node = this.cache.get(key);
+		if (!node) return void 0;
+		this.moveToHead(node);
+		return node.data;
+	}
+	/**
+	* Returns an iterator over the cache entries. The order is outputted in the
+	* order of most recently used to least recently used.
+	*/
+	*[Symbol.iterator]() {
+		let current = this.head.next;
+		while (current && current !== this.tail) {
+			const node = current;
+			yield [node.key, node.data];
+			current = current.next;
+		}
+	}
+	/**
+	* Removes a specific key from the cache.
+	* Updates both the hash map and doubly-linked list.
+	*
+	* Time Complexity: O(1)
+	*/
+	remove(key) {
+		const node = this.cache.get(key);
+		if (!node) return;
+		this.removeNode(node);
+		this.cache.delete(key);
+		this.totalSize -= node.size;
+	}
+	/**
+	* Returns the number of items in the cache.
+	*/
+	get size() {
+		return this.cache.size;
+	}
+	/**
+	* Returns the current total size of all cached items.
+	* This uses the custom size calculation if provided.
+	*/
+	get currentSize() {
+		return this.totalSize;
+	}
+};
+
+//#endregion
+export { LRUCache };
 //# sourceMappingURL=lru-cache.mjs.map

package/dist/lru-cache.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"lru-cache.mjs","names":[],"sources":["../src/lru-cache.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nclass LRUNode<T> {\n  public readonly key: string;\n\n  public data: T;\n\n  public size: number;\n\n  public prev: LRUNode<T> | SentinelNode<T> | null = null;\n\n  public next: LRUNode<T> | SentinelNode<T> | null = null;\n\n  constructor(key: string, data: T, size: number) {\n    this.key = key;\n    this.data = data;\n    this.size = size;\n  }\n}\n\n/**\n * Sentinel node used for head/tail boundaries.\n * These nodes don't contain actual cache data but simplify list operations.\n */\nclass SentinelNode<T> {\n  public prev: LRUNode<T> | SentinelNode<T> | null = null;\n\n  public next: LRUNode<T> | SentinelNode<T> | null = null;\n}\n\n/**\n * LRU (Least Recently Used) Cache implementation using a doubly-linked list\n * and hash map for O(1) operations.\n *\n * Algorithm:\n * - Uses a doubly-linked list to maintain access order (most recent at head)\n * - Hash map provides O(1) key-to-node lookup\n * - Sentinel head/tail nodes simplify edge case handling\n * - Size-based eviction supports custom size calculation functions\n *\n * Data Structure Layout:\n * HEAD \\<-\\> [most recent] \\<-\\> ... \\<-\\> [least recent] \\<-\\> TAIL\n *\n * Operations:\n * - get(): Move accessed node to head (mark as most recent)\n * - set(): Add new node at head, evict from tail if over capacity\n * - Eviction: Remove least recent node (tail.prev) when size exceeds limit\n */\nexport class LRUCache<T> {\n  private readonly cache: Map<string, LRUNode<T>> = new Map();\n\n  private readonly head: SentinelNode<T>;\n\n  private readonly tail: SentinelNode<T>;\n\n  private totalSize: number = 0;\n\n  private readonly maxSize: number;\n\n  private readonly calculateSize: ((value: T) => number) | undefined;\n\n  constructor(maxSize: number, calculateSize?: (value: T) => number) {\n    this.maxSize = maxSize;\n    this.calculateSize = calculateSize;\n\n    // Create sentinel nodes to simplify doubly-linked list operations\n    // HEAD <-> TAIL (empty list)\n    this.head = new SentinelNode<T>();\n    this.tail = new SentinelNode<T>();\n    this.head.next = this.tail;\n    this.tail.prev = this.head;\n  }\n\n  /**\n   * Adds a node immediately after the head (marks as most recently used). Used when inserting new items or when an item is accessed. **PRECONDITION:** node must be disconnected (prev/next should be null)\n   *\n   * @param node - The node to add after the head.\n   */\n  private addToHead(node: LRUNode<T>): void {\n    node.prev = this.head;\n    node.next = this.head.next;\n    // head.next is always non-null (points to tail or another node)\n    this.head.next!.prev = node;\n    this.head.next = node;\n  }\n\n  /**\n   * Removes a node from its current position in the doubly-linked list. Updates the prev/next pointers of adjacent nodes to maintain list integrity. **PRECONDITION:** node must be connected (prev/next are non-null)\n   *\n   * @param node - The node to remove from the list.\n   */\n  private removeNode(node: LRUNode<T>): void {\n    // Connected nodes always have non-null prev/next\n    node.prev!.next = node.next;\n    node.next!.prev = node.prev;\n  }\n\n  /**\n   * Moves an existing node to the head position (marks as most recently used). This is the core LRU operation - accessed items become most recent.\n   *\n   * @param node - The node to move to the head.\n   */\n  private moveToHead(node: LRUNode<T>): void {\n    this.removeNode(node);\n    this.addToHead(node);\n  }\n\n  /**\n   * Removes and returns the least recently used node (the one before tail). This is called during eviction when the cache exceeds capacity. **PRECONDITION:** cache is not empty (ensured by caller)\n   *\n   * @returns The removed least recently used node.\n   */\n  private removeTail(): LRUNode<T> {\n    const lastNode = this.tail.prev as LRUNode<T>;\n    // tail.prev is always non-null and always LRUNode when cache is not empty\n    this.removeNode(lastNode);\n    return lastNode;\n  }\n\n  /**\n   * Sets a key-value pair in the cache.\n   * If the key exists, updates the value and moves to head.\n   * If new, adds at head and evicts from tail if necessary.\n   *\n   * Time Complexity:\n   * - O(1) for uniform item sizes\n   * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)\n   *\n   * @param key - The key to set.\n   * @param value - The value to set.\n   */\n  public set(key: string, value: T): void {\n    const size = this.calculateSize?.(value) ?? 1;\n    if (size > this.maxSize) {\n      // console.warn(\"Single item size exceeds maxSize\");\n      return;\n    }\n\n    const existing = this.cache.get(key);\n    if (existing) {\n      // Update existing node: adjust size and move to head (most recent)\n      existing.data = value;\n      this.totalSize = this.totalSize - existing.size + size;\n      existing.size = size;\n      this.moveToHead(existing);\n    } else {\n      // Add new node at head (most recent position)\n      const newNode = new LRUNode(key, value, size);\n      this.cache.set(key, newNode);\n      this.addToHead(newNode);\n      this.totalSize += size;\n    }\n\n    // Evict least recently used items until under capacity\n    while (this.totalSize > this.maxSize && this.cache.size > 0) {\n      const tail = this.removeTail();\n      this.cache.delete(tail.key);\n      this.totalSize -= tail.size;\n    }\n  }\n\n  /**\n   * Checks if a key exists in the cache.\n   * This is a pure query operation - does NOT update LRU order.\n   *\n   * Time Complexity: O(1)\n   */\n  public has(key: string): boolean {\n    return this.cache.has(key);\n  }\n\n  /**\n   * Retrieves a value by key and marks it as most recently used.\n   * Moving to head maintains the LRU property for future evictions.\n   *\n   * Time Complexity: O(1)\n   */\n  public get(key: string): T | undefined {\n    const node = this.cache.get(key);\n    if (!node) return undefined;\n\n    // Mark as most recently used by moving to head\n    this.moveToHead(node);\n\n    return node.data;\n  }\n\n  /**\n   * Returns an iterator over the cache entries. The order is outputted in the\n   * order of most recently used to least recently used.\n   */\n  public *[Symbol.iterator](): IterableIterator<[string, T]> {\n    let current = this.head.next;\n    while (current && current !== this.tail) {\n      // Between head and tail, current is always LRUNode\n      const node = current as LRUNode<T>;\n      yield [node.key, node.data];\n      current = current.next;\n    }\n  }\n\n  /**\n   * Removes a specific key from the cache.\n   * Updates both the hash map and doubly-linked list.\n   *\n   * Time Complexity: O(1)\n   */\n  public remove(key: string): void {\n    const node = this.cache.get(key);\n    if (!node) return;\n\n    this.removeNode(node);\n    this.cache.delete(key);\n    this.totalSize -= node.size;\n  }\n\n  /**\n   * Returns the number of items in the cache.\n   */\n  public get size(): number {\n    return this.cache.size;\n  }\n\n  /**\n   * Returns the current total size of all cached items.\n   * This uses the custom size calculation if provided.\n   */\n  public get currentSize(): number {\n    return this.totalSize;\n  }\n}\n"],"mappings":"AAkBA,IAAM,EAAN,KAAiB,CACf,IAEA,KAEA,KAEA,KAAmD,KAEnD,KAAmD,KAEnD,YAAY,EAAa,EAAS,EAAc,CAC9C,KAAK,IAAM,EACX,KAAK,KAAO,EACZ,KAAK,KAAO,IAQV,EAAN,KAAsB,CACpB,KAAmD,KAEnD,KAAmD,MAqBxC,EAAb,KAAyB,CACvB,MAAkD,IAAI,IAEtD,KAEA,KAEA,UAA4B,EAE5B,QAEA,cAEA,YAAY,EAAiB,EAAsC,CACjE,KAAK,QAAU,EACf,KAAK,cAAgB,EAIrB,KAAK,KAAO,IAAI,EAChB,KAAK,KAAO,IAAI,EAChB,KAAK,KAAK,KAAO,KAAK,KACtB,KAAK,KAAK,KAAO,KAAK,KAQxB,UAAkB,EAAwB,CACxC,EAAK,KAAO,KAAK,KACjB,EAAK,KAAO,KAAK,KAAK,KAEtB,KAAK,KAAK,KAAM,KAAO,EACvB,KAAK,KAAK,KAAO,EAQnB,WAAmB,EAAwB,CAEzC,EAAK,KAAM,KAAO,EAAK,KACvB,EAAK,KAAM,KAAO,EAAK,KAQzB,WAAmB,EAAwB,CACzC,KAAK,WAAW,EAAK,CACrB,KAAK,UAAU,EAAK,CAQtB,YAAiC,CAC/B,IAAM,EAAW,KAAK,KAAK,KAG3B,OADA,KAAK,WAAW,EAAS,CAClB,EAeT,IAAW,EAAa,EAAgB,CACtC,IAAM,EAAO,KAAK,gBAAgB,EAAM,EAAI,EAC5C,GAAI,EAAO,KAAK,QAEd,OAGF,IAAM,EAAW,KAAK,MAAM,IAAI,EAAI,CACpC,GAAI,EAEF,EAAS,KAAO,EAChB,KAAK,UAAY,KAAK,UAAY,EAAS,KAAO,EAClD,EAAS,KAAO,EAChB,KAAK,WAAW,EAAS,KACpB,CAEL,IAAM,EAAU,IAAI,EAAQ,EAAK,EAAO,EAAK,CAC7C,KAAK,MAAM,IAAI,EAAK,EAAQ,CAC5B,KAAK,UAAU,EAAQ,CACvB,KAAK,WAAa,EAIpB,KAAO,KAAK,UAAY,KAAK,SAAW,KAAK,MAAM,KAAO,GAAG,CAC3D,IAAM,EAAO,KAAK,YAAY,CAC9B,KAAK,MAAM,OAAO,EAAK,IAAI,CAC3B,KAAK,WAAa,EAAK,MAU3B,IAAW,EAAsB,CAC/B,OAAO,KAAK,MAAM,IAAI,EAAI,CAS5B,IAAW,EAA4B,CACrC,IAAM,EAAO,KAAK,MAAM,IAAI,EAAI,CAC3B,KAKL,OAFA,KAAK,WAAW,EAAK,CAEd,EAAK,KAOd,EAAS,OAAO,WAA2C,CACzD,IAAI,EAAU,KAAK,KAAK,KACxB,KAAO,GAAW,IAAY,KAAK,MAAM,CAEvC,IAAM,EAAO,EACb,KAAM,CAAC,EAAK,IAAK,EAAK,KAAK,CAC3B,EAAU,EAAQ,MAUtB,OAAc,EAAmB,CAC/B,IAAM,EAAO,KAAK,MAAM,IAAI,EAAI,CAC3B,IAEL,KAAK,WAAW,EAAK,CACrB,KAAK,MAAM,OAAO,EAAI,CACtB,KAAK,WAAa,EAAK,MAMzB,IAAW,MAAe,CACxB,OAAO,KAAK,MAAM,KAOpB,IAAW,aAAsB,CAC/B,OAAO,KAAK"}
+{"version":3,"file":"lru-cache.mjs","names":[],"sources":["../src/lru-cache.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nclass LRUNode<T> {\n  public readonly key: string;\n\n  public data: T;\n\n  public size: number;\n\n  public prev: LRUNode<T> | SentinelNode<T> | null = null;\n\n  public next: LRUNode<T> | SentinelNode<T> | null = null;\n\n  constructor(key: string, data: T, size: number) {\n    this.key = key;\n    this.data = data;\n    this.size = size;\n  }\n}\n\n/**\n * Sentinel node used for head/tail boundaries.\n * These nodes don't contain actual cache data but simplify list operations.\n */\nclass SentinelNode<T> {\n  public prev: LRUNode<T> | SentinelNode<T> | null = null;\n\n  public next: LRUNode<T> | SentinelNode<T> | null = null;\n}\n\n/**\n * LRU (Least Recently Used) Cache implementation using a doubly-linked list\n * and hash map for O(1) operations.\n *\n * Algorithm:\n * - Uses a doubly-linked list to maintain access order (most recent at head)\n * - Hash map provides O(1) key-to-node lookup\n * - Sentinel head/tail nodes simplify edge case handling\n * - Size-based eviction supports custom size calculation functions\n *\n * Data Structure Layout:\n * HEAD \\<-\\> [most recent] \\<-\\> ... \\<-\\> [least recent] \\<-\\> TAIL\n *\n * Operations:\n * - get(): Move accessed node to head (mark as most recent)\n * - set(): Add new node at head, evict from tail if over capacity\n * - Eviction: Remove least recent node (tail.prev) when size exceeds limit\n */\nexport class LRUCache<T> {\n  private readonly cache: Map<string, LRUNode<T>> = new Map();\n\n  private readonly head: SentinelNode<T>;\n\n  private readonly tail: SentinelNode<T>;\n\n  private totalSize: number = 0;\n\n  private readonly maxSize: number;\n\n  private readonly calculateSize: ((value: T) => number) | undefined;\n\n  constructor(maxSize: number, calculateSize?: (value: T) => number) {\n    this.maxSize = maxSize;\n    this.calculateSize = calculateSize;\n\n    // Create sentinel nodes to simplify doubly-linked list operations\n    // HEAD <-> TAIL (empty list)\n    this.head = new SentinelNode<T>();\n    this.tail = new SentinelNode<T>();\n    this.head.next = this.tail;\n    this.tail.prev = this.head;\n  }\n\n  /**\n   * Adds a node immediately after the head (marks as most recently used). Used when inserting new items or when an item is accessed. **PRECONDITION:** node must be disconnected (prev/next should be null)\n   *\n   * @param node - The node to add after the head.\n   */\n  private addToHead(node: LRUNode<T>): void {\n    node.prev = this.head;\n    node.next = this.head.next;\n    // head.next is always non-null (points to tail or another node)\n    this.head.next!.prev = node;\n    this.head.next = node;\n  }\n\n  /**\n   * Removes a node from its current position in the doubly-linked list. Updates the prev/next pointers of adjacent nodes to maintain list integrity. **PRECONDITION:** node must be connected (prev/next are non-null)\n   *\n   * @param node - The node to remove from the list.\n   */\n  private removeNode(node: LRUNode<T>): void {\n    // Connected nodes always have non-null prev/next\n    node.prev!.next = node.next;\n    node.next!.prev = node.prev;\n  }\n\n  /**\n   * Moves an existing node to the head position (marks as most recently used). This is the core LRU operation - accessed items become most recent.\n   *\n   * @param node - The node to move to the head.\n   */\n  private moveToHead(node: LRUNode<T>): void {\n    this.removeNode(node);\n    this.addToHead(node);\n  }\n\n  /**\n   * Removes and returns the least recently used node (the one before tail). This is called during eviction when the cache exceeds capacity. **PRECONDITION:** cache is not empty (ensured by caller)\n   *\n   * @returns The removed least recently used node.\n   */\n  private removeTail(): LRUNode<T> {\n    const lastNode = this.tail.prev as LRUNode<T>;\n    // tail.prev is always non-null and always LRUNode when cache is not empty\n    this.removeNode(lastNode);\n    return lastNode;\n  }\n\n  /**\n   * Sets a key-value pair in the cache.\n   * If the key exists, updates the value and moves to head.\n   * If new, adds at head and evicts from tail if necessary.\n   *\n   * Time Complexity:\n   * - O(1) for uniform item sizes\n   * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)\n   *\n   * @param key - The key to set.\n   * @param value - The value to set.\n   */\n  public set(key: string, value: T): void {\n    const size = this.calculateSize?.(value) ?? 1;\n    if (size > this.maxSize) {\n      // console.warn(\"Single item size exceeds maxSize\");\n      return;\n    }\n\n    const existing = this.cache.get(key);\n    if (existing) {\n      // Update existing node: adjust size and move to head (most recent)\n      existing.data = value;\n      this.totalSize = this.totalSize - existing.size + size;\n      existing.size = size;\n      this.moveToHead(existing);\n    } else {\n      // Add new node at head (most recent position)\n      const newNode = new LRUNode(key, value, size);\n      this.cache.set(key, newNode);\n      this.addToHead(newNode);\n      this.totalSize += size;\n    }\n\n    // Evict least recently used items until under capacity\n    while (this.totalSize > this.maxSize && this.cache.size > 0) {\n      const tail = this.removeTail();\n      this.cache.delete(tail.key);\n      this.totalSize -= tail.size;\n    }\n  }\n\n  /**\n   * Checks if a key exists in the cache.\n   * This is a pure query operation - does NOT update LRU order.\n   *\n   * Time Complexity: O(1)\n   */\n  public has(key: string): boolean {\n    return this.cache.has(key);\n  }\n\n  /**\n   * Retrieves a value by key and marks it as most recently used.\n   * Moving to head maintains the LRU property for future evictions.\n   *\n   * Time Complexity: O(1)\n   */\n  public get(key: string): T | undefined {\n    const node = this.cache.get(key);\n    if (!node) return undefined;\n\n    // Mark as most recently used by moving to head\n    this.moveToHead(node);\n\n    return node.data;\n  }\n\n  /**\n   * Returns an iterator over the cache entries. The order is outputted in the\n   * order of most recently used to least recently used.\n   */\n  public *[Symbol.iterator](): IterableIterator<[string, T]> {\n    let current = this.head.next;\n    while (current && current !== this.tail) {\n      // Between head and tail, current is always LRUNode\n      const node = current as LRUNode<T>;\n      yield [node.key, node.data];\n      current = current.next;\n    }\n  }\n\n  /**\n   * Removes a specific key from the cache.\n   * Updates both the hash map and doubly-linked list.\n   *\n   * Time Complexity: O(1)\n   */\n  public remove(key: string): void {\n    const node = this.cache.get(key);\n    if (!node) return;\n\n    this.removeNode(node);\n    this.cache.delete(key);\n    this.totalSize -= node.size;\n  }\n\n  /**\n   * Returns the number of items in the cache.\n   */\n  public get size(): number {\n    return this.cache.size;\n  }\n\n  /**\n   * Returns the current total size of all cached items.\n   * This uses the custom size calculation if provided.\n   */\n  public get currentSize(): number {\n    return this.totalSize;\n  }\n}\n"],"mappings":";AAkBA,IAAM,UAAN,MAAiB;CACf,AAAgB;CAEhB,AAAO;CAEP,AAAO;CAEP,AAAO,OAA4C;CAEnD,AAAO,OAA4C;CAEnD,YAAY,KAAa,MAAS,MAAc;AAC9C,OAAK,MAAM;AACX,OAAK,OAAO;AACZ,OAAK,OAAO;;;;;;;AAQhB,IAAM,eAAN,MAAsB;CACpB,AAAO,OAA4C;CAEnD,AAAO,OAA4C;;;;;;;;;;;;;;;;;;;;AAqBrD,IAAa,WAAb,MAAyB;CACvB,AAAiB,wBAAiC,IAAI,KAAK;CAE3D,AAAiB;CAEjB,AAAiB;CAEjB,AAAQ,YAAoB;CAE5B,AAAiB;CAEjB,AAAiB;CAEjB,YAAY,SAAiB,eAAsC;AACjE,OAAK,UAAU;AACf,OAAK,gBAAgB;AAIrB,OAAK,OAAO,IAAI,cAAiB;AACjC,OAAK,OAAO,IAAI,cAAiB;AACjC,OAAK,KAAK,OAAO,KAAK;AACtB,OAAK,KAAK,OAAO,KAAK;;;;;;;CAQxB,AAAQ,UAAU,MAAwB;AACxC,OAAK,OAAO,KAAK;AACjB,OAAK,OAAO,KAAK,KAAK;AAEtB,OAAK,KAAK,KAAM,OAAO;AACvB,OAAK,KAAK,OAAO;;;;;;;CAQnB,AAAQ,WAAW,MAAwB;AAEzC,OAAK,KAAM,OAAO,KAAK;AACvB,OAAK,KAAM,OAAO,KAAK;;;;;;;CAQzB,AAAQ,WAAW,MAAwB;AACzC,OAAK,WAAW,KAAK;AACrB,OAAK,UAAU,KAAK;;;;;;;CAQtB,AAAQ,aAAyB;EAC/B,MAAM,WAAW,KAAK,KAAK;AAE3B,OAAK,WAAW,SAAS;AACzB,SAAO;;;;;;;;;;;;;;CAeT,AAAO,IAAI,KAAa,OAAgB;EACtC,MAAM,OAAO,KAAK,gBAAgB,MAAM,IAAI;AAC5C,MAAI,OAAO,KAAK,QAEd;EAGF,MAAM,WAAW,KAAK,MAAM,IAAI,IAAI;AACpC,MAAI,UAAU;AAEZ,YAAS,OAAO;AAChB,QAAK,YAAY,KAAK,YAAY,SAAS,OAAO;AAClD,YAAS,OAAO;AAChB,QAAK,WAAW,SAAS;SACpB;GAEL,MAAM,UAAU,IAAI,QAAQ,KAAK,OAAO,KAAK;AAC7C,QAAK,MAAM,IAAI,KAAK,QAAQ;AAC5B,QAAK,UAAU,QAAQ;AACvB,QAAK,aAAa;;AAIpB,SAAO,KAAK,YAAY,KAAK,WAAW,KAAK,MAAM,OAAO,GAAG;GAC3D,MAAM,OAAO,KAAK,YAAY;AAC9B,QAAK,MAAM,OAAO,KAAK,IAAI;AAC3B,QAAK,aAAa,KAAK;;;;;;;;;CAU3B,AAAO,IAAI,KAAsB;AAC/B,SAAO,KAAK,MAAM,IAAI,IAAI;;;;;;;;CAS5B,AAAO,IAAI,KAA4B;EACrC,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,MAAI,CAAC,KAAM,QAAO;AAGlB,OAAK,WAAW,KAAK;AAErB,SAAO,KAAK;;;;;;CAOd,EAAS,OAAO,YAA2C;EACzD,IAAI,UAAU,KAAK,KAAK;AACxB,SAAO,WAAW,YAAY,KAAK,MAAM;GAEvC,MAAM,OAAO;AACb,SAAM,CAAC,KAAK,KAAK,KAAK,KAAK;AAC3B,aAAU,QAAQ;;;;;;;;;CAUtB,AAAO,OAAO,KAAmB;EAC/B,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,MAAI,CAAC,KAAM;AAEX,OAAK,WAAW,KAAK;AACrB,OAAK,MAAM,OAAO,IAAI;AACtB,OAAK,aAAa,KAAK;;;;;CAMzB,IAAW,OAAe;AACxB,SAAO,KAAK,MAAM;;;;;;CAOpB,IAAW,cAAsB;AAC/B,SAAO,KAAK"}