@creejs/commons-collection 2.0.4 → 2.0.6

package/dist/cjs/index-dev.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function a$1(t){return "boolean"==typeof t}function c$1(t){return "function"==typeof t}function l$1(t){return null!=t&&"object"==typeof t&&!A(t)}function y(t){return null==t}function p$1(t){return !!m$1(t)&&t>0}function h$1(t){return !!m$1(t)&&t>=0}function g$1(t){return !!m$1(t)&&t<0}function w$1(t){return null===t}function d$1(t){return void 0===t}function m$1(t){return null!=t&&"number"==typeof t}function b$1(t){return null!=t&&"object"==typeof t}function A(t){return null!==t&&"object"==typeof t&&(t.constructor===Object||void 0===t.constructor)}function E(t){return null!=t&&"function"==typeof t.then}function N(t){return null!=t&&"string"==typeof t}function $(t){return null!=t&&"symbol"==typeof t}function O$1(t){return ArrayBuffer.isView(t)&&t.constructor!==DataView}function v$1(t){return t instanceof Int8Array}function j(t){return t instanceof Uint8Array}function P(t){return t instanceof Uint8ClampedArray}function S(t){return t instanceof Int16Array}function x(t){return t instanceof Uint16Array}function U(t){return t instanceof Int32Array}function T(t){return t instanceof Uint32Array}function I(t){return t instanceof Float32Array}function B(t){return t instanceof Float64Array}function k$1(t){return t instanceof BigInt64Array}function L$1(t){return t instanceof BigUint64Array}function F(t){return t instanceof ArrayBuffer}var C={assertNumber:q,assertPositive:_$1,assertNegative:function(t,r){if(!g$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Negative: ${t}`)},assertNotNegative:J,assertBoolean:function(t,r){if(!a$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Boolean: type=${typeof t} value=${Z(t)}`)},assertObject:R,assertPlainObject:function(t,r){if(!A(t))throw new Error(`${r?'"'+r+'" ':""}Not PlainObject: type=${typeof t} value=${Z(t)}`)},assertSymbol:function(t,r){if(!$(t))throw new Error(`${r?'"'+r+'" ':""}Not Symbol: type=${typeof t} value=${Z(t)}`)},assertFunction:W,assertInstance:function(t,r){if(!l$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Class Instance: type=${typeof t} value=${Z(t)}`)},assertPromise:H,assertNil:function(t,r){if(!y(t))throw new Error(`${r?'"'+r+'" ':""}Neither Null nor Undefined: type=${typeof t} value=${Z(t)}`)},assertNotNil:V,assertNull:function(t,r){if(!w$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Null: type=${typeof t} value=${Z(t)}`)},assertNotNull:function(t,r){if(w$1(t))throw new Error((r?'"'+r+'" ':"")+"Should Not Null")},assertUndefined:function(t,r){if(!d$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Undefined: type=${typeof t} value=${Z(t)}`)},assertString:M,assertArray:D,assertStringOrSymbol:function(t,r){if(!N(t)&&!$(t))throw new Error(`${r?'"'+r+'" ':""}Not String or Symbol: type=${typeof t} value=${Z(t)}`)},assertInt8Array:function(t,r){if(v$1(t))throw new Error((r?'"'+r+'" ':"")+"Not Int8Array")},assertUint8Array:function(t,r){if(j(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint8Array")},assertUint8ClampedArray:function(t,r){if(P(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint8ClampedArray")},assertInt16Array:function(t,r){if(S(t))throw new Error((r?'"'+r+'" ':"")+"Not Int16Array")},assertUint16Array:function(t,r){if(x(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint16Array")},assertInt32Array:function(t,r){if(U(t))throw new Error((r?'"'+r+'" ':"")+"Not Int32Array")},assertUint32Array:function(t,r){if(T(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint32Array")},assertFloat32Array:function(t,r){if(I(t))throw new Error((r?'"'+r+'" ':"")+"Not Float32Array")},assertFloat64Array:function(t,r){if(B(t))throw new Error((r?'"'+r+'" ':"")+"Not Float64Array")},assertBigInt64Array:function(t,r){if(k$1(t))throw new Error((r?'"'+r+'" ':"")+"Not BigInt64Array")},assertBigUint64Array:function(t,r){if(L$1(t))throw new Error((r?'"'+r+'" ':"")+"Not BigUint64Array")},assertTypedArray:function(t,r){if(O$1(t))throw new Error((r?'"'+r+'" ':"")+"Not TypedArray")},assertArrayBuffer:z};function D(t,r){if(!Array.isArray(t))throw new Error(`${r?'"'+r+'" ':""}Not Array: type=${typeof t} value=${Z(t)}`)}function M(t,r){if(!N(t))throw new Error(`${r?'"'+r+'" ':""}Not String: type=${typeof t} value=${Z(t)}`)}function q(t,r){if(!m$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Number: type=${typeof t} value=${Z(t)}`)}function _$1(t,r){if(!p$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Positive: ${t}`)}function J(t,r){if(!h$1(t))throw new Error(`${r?'"'+r+'" ':""}Not "0 or Positive": ${t}`)}function R(t,r){if(!b$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Object: type=${typeof t} value=${Z(t)}`)}function W(t,r){if(!c$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Function: type=${typeof t} value=${Z(t)}`)}function H(t,r){if(!E(t))throw new Error(`${r?'"'+r+'" ':""}Not Promise: type=${typeof t} value=${Z(t)}`)}function V(t,r){if(y(t))throw new Error((r?'"'+r+'" ':"")+"Should Not Nil")}function z(t,r){if(!F(t))throw new Error((r?'"'+r+'" ':"")+"Not ArrayBuffer")}function Z(t){if(null===t)return "null";if(void 0===t)return "undefined";let r;try{r=JSON.stringify(t);}catch(e){r=t.toString();}return r}new TextDecoder;new TextEncoder;const dt=1e6;var mt={s2ns:1e9,ms2ns:dt,timestamp:function(){if("undefined"!=typeof performance&&"number"==typeof performance.timeOrigin){const t=performance.timeOrigin,r=performance.now();return Math.ceil((t+r)/dt)}return Date.now()},timestamp64:bt,lapseNano:At,lapseMillis:Et,timeoutNano:function(t,r){return At(t)>r},timeoutMillis:function(t,r){return Et(t)>r}};function bt(){if("undefined"!=typeof performance&&"number"==typeof performance.timeOrigin){const t=performance.timeOrigin,r=performance.now();return BigInt((t+r)*dt)}return BigInt(Date.now()*dt)}function At(t,r){return (r??bt())-t}function Et(t,r){r=r??bt();return BigInt(r-t)/BigInt(dt)}
+function a$1(t){return "boolean"==typeof t}function c$1(t){return "function"==typeof t}function l$1(t){return null!=t&&"object"==typeof t&&!A(t)}function y(t){return null==t}function p$1(t){return !!m$1(t)&&t>0}function h$1(t){return !!m$1(t)&&t>=0}function g$1(t){return !!m$1(t)&&t<0}function w$1(t){return null===t}function d$1(t){return void 0===t}function m$1(t){return null!=t&&"number"==typeof t}function b$1(t){return null!=t&&"object"==typeof t}function A(t){return null!==t&&"object"==typeof t&&(t.constructor===Object||void 0===t.constructor)}function E(t){return null!=t&&"function"==typeof t.then}function N(t){return null!=t&&"string"==typeof t}function $(t){return null!=t&&"symbol"==typeof t}function O$1(t){return ArrayBuffer.isView(t)&&t.constructor!==DataView}function v$1(t){return t instanceof Int8Array}function P(t){return t instanceof Uint8Array}function j(t){return t instanceof Uint8ClampedArray}function S(t){return t instanceof Int16Array}function x(t){return t instanceof Uint16Array}function U(t){return t instanceof Int32Array}function T(t){return t instanceof Uint32Array}function I(t){return t instanceof Float32Array}function B(t){return t instanceof Float64Array}function k$1(t){return t instanceof BigInt64Array}function L$1(t){return t instanceof BigUint64Array}function F(t){return t instanceof ArrayBuffer}var C={assertNumber:q,assertPositive:_$1,assertNegative:function(t,r){if(!g$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Negative: ${t}`)},assertNotNegative:R,assertBoolean:function(t,r){if(!a$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Boolean: type=${typeof t} value=${Z(t)}`)},assertObject:J,assertPlainObject:function(t,r){if(!A(t))throw new Error(`${r?'"'+r+'" ':""}Not PlainObject: type=${typeof t} value=${Z(t)}`)},assertSymbol:function(t,r){if(!$(t))throw new Error(`${r?'"'+r+'" ':""}Not Symbol: type=${typeof t} value=${Z(t)}`)},assertFunction:W,assertInstance:function(t,r){if(!l$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Class Instance: type=${typeof t} value=${Z(t)}`)},assertPromise:H,assertNil:function(t,r){if(!y(t))throw new Error(`${r?'"'+r+'" ':""}Neither Null nor Undefined: type=${typeof t} value=${Z(t)}`)},assertNotNil:V,assertNull:function(t,r){if(!w$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Null: type=${typeof t} value=${Z(t)}`)},assertNotNull:function(t,r){if(w$1(t))throw new Error((r?'"'+r+'" ':"")+"Should Not Null")},assertUndefined:function(t,r){if(!d$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Undefined: type=${typeof t} value=${Z(t)}`)},assertString:D,assertArray:M,assertStringOrSymbol:function(t,r){if(!N(t)&&!$(t))throw new Error(`${r?'"'+r+'" ':""}Not String or Symbol: type=${typeof t} value=${Z(t)}`)},assertInt8Array:function(t,r){if(v$1(t))throw new Error((r?'"'+r+'" ':"")+"Not Int8Array")},assertUint8Array:function(t,r){if(P(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint8Array")},assertUint8ClampedArray:function(t,r){if(j(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint8ClampedArray")},assertInt16Array:function(t,r){if(S(t))throw new Error((r?'"'+r+'" ':"")+"Not Int16Array")},assertUint16Array:function(t,r){if(x(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint16Array")},assertInt32Array:function(t,r){if(U(t))throw new Error((r?'"'+r+'" ':"")+"Not Int32Array")},assertUint32Array:function(t,r){if(T(t))throw new Error((r?'"'+r+'" ':"")+"Not Uint32Array")},assertFloat32Array:function(t,r){if(I(t))throw new Error((r?'"'+r+'" ':"")+"Not Float32Array")},assertFloat64Array:function(t,r){if(B(t))throw new Error((r?'"'+r+'" ':"")+"Not Float64Array")},assertBigInt64Array:function(t,r){if(k$1(t))throw new Error((r?'"'+r+'" ':"")+"Not BigInt64Array")},assertBigUint64Array:function(t,r){if(L$1(t))throw new Error((r?'"'+r+'" ':"")+"Not BigUint64Array")},assertTypedArray:function(t,r){if(O$1(t))throw new Error((r?'"'+r+'" ':"")+"Not TypedArray")},assertArrayBuffer:z};function M(t,r){if(!Array.isArray(t))throw new Error(`${r?'"'+r+'" ':""}Not Array: type=${typeof t} value=${Z(t)}`)}function D(t,r){if(!N(t))throw new Error(`${r?'"'+r+'" ':""}Not String: type=${typeof t} value=${Z(t)}`)}function q(t,r){if(!m$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Number: type=${typeof t} value=${Z(t)}`)}function _$1(t,r){if(!p$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Positive: ${t}`)}function R(t,r){if(!h$1(t))throw new Error(`${r?'"'+r+'" ':""}Not "0 or Positive": ${t}`)}function J(t,r){if(!b$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Object: type=${typeof t} value=${Z(t)}`)}function W(t,r){if(!c$1(t))throw new Error(`${r?'"'+r+'" ':""}Not Function: type=${typeof t} value=${Z(t)}`)}function H(t,r){if(!E(t))throw new Error(`${r?'"'+r+'" ':""}Not Promise: type=${typeof t} value=${Z(t)}`)}function V(t,r){if(y(t))throw new Error((r?'"'+r+'" ':"")+"Should Not Nil")}function z(t,r){if(!F(t))throw new Error((r?'"'+r+'" ':"")+"Not ArrayBuffer")}var G={isEmpty:K,assertNotEmpty:Y,isBlank:Q,assertNotBlank:function(t,r){if(Q(t))throw new Error(`${r?'"'+r+'" ':""}Is Blank: ${t}`)},capitalize:function(t){if(D(t),0===t.length)return t;const r=t.charAt(0),e=r.toUpperCase();return r===e?t:e+t.slice(1)},decapitalize:function(t){if(D(t),0===t.length)return t;const r=t.charAt(0),e=r.toLowerCase();return r===e?t:e+t.slice(1)},splitWithFixedLength:function(t,r,e=" "){if(D(t),q(r),D(e),0===t.length)return [];if(r<=0)throw new Error("length muse >=0");if(t.length<r)return [t.padEnd(r,e)];const n=[];for(let o=0;o<t.length;o+=r){const i=t.substring(o,o+r);n.push(i.padEnd(r,e));}return n},split:function(t,...r){D(t);if(0===t.length)return [];const e=[...r];0===r.length&&r.push(",");const n=X(t,...e);if(0===n.length)return [];const o=[];let i="",s=0;for(const{marker:r,index:e}of n)i=t.substring(s,e),o.push(i),s=e+r.length;return i=t.substring(s),o.push(i),o},findMarkerPositions:function(t,...r){if(D(t),0===r.length)throw new Error("At least one marker must be provided");const e=[];for(const n of new Set(r)){if(K(n))continue;D(n);let r=t.indexOf(n);for(;-1!==r;)e.push({marker:n,index:r}),r=t.indexOf(n,r+n.length);}return e.sort((t,r)=>t.index-r.index),e},findMarkerPositionsRegex:X,substringBefore:function(t,r){if(D(t),D(r),0===t.length||0===r.length)return;const e=t.indexOf(r);if(-1===e)return;return t.substring(0,e)},substringBeforeLast:function(t,r){if(D(t),D(r),0===t.length||0===r.length)return;const e=t.lastIndexOf(r);if(-1===e)return;return t.substring(0,e)},substringAfter:function(t,r){if(D(t),D(r),0===t.length||0===r.length)return;const e=t.indexOf(r);if(-1===e)return;return t.substring(e+r.length)},substringAfterLast:function(t,r){if(D(t),D(r),0===t.length||0===r.length)return;const e=t.lastIndexOf(r);if(-1===e)return;return t.substring(e+r.length)},substringBetween:function(t,r,e){Y(t),Y(r),Y(e);const n=t.indexOf(r);if(-1===n)return;const o=t.indexOf(e,n+r.length);if(-1===o)return;return t.substring(n+r.length,o)},substringBetweenGreedy:function(t,r,e){Y(t),Y(r),Y(e);const n=t.indexOf(r);if(-1===n)return;const o=t.lastIndexOf(e);if(-1===o||o<=n)return;return t.substring(n+r.length,o)},substringsBetween:function(t,r,e){Y(t),Y(r),Y(e);const n=[];let o=0;for(;;){const i=t.indexOf(r,o);if(-1===i)break;const s=t.indexOf(e,i+r.length);if(-1===s)break;n.push(t.substring(i+r.length,s)),o=s+e.length;}return n},safeToString:Z};function K(t){return null==t||(D(t),0===t.length)}function Y(t,r){if(K(t))throw new Error(`${r?'"'+r+'" ':""}IsEmpty String: ${t}`)}function Q(t){return null==t||(D(t),0===t.trim().length)}function X(t,...r){if(D(t),0===r.length)throw new Error("At least one marker must be provided");const e=[...new Set(r.filter(t=>null!=t))].map(t=>(D(t),t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"))),n=new RegExp(e.map(t=>`(${t})`).join("|"),"g"),o=[];let i=null;for(;null!==(i=n.exec(t));){for(let t=1;t<i.length;t++)if(i[t]){o.push({marker:r[t-1],index:i.index});break}0===i[0].length&&n.lastIndex++;}return o}function Z(t){if(null===t)return "null";if(void 0===t)return "undefined";const r=typeof t;if("string"===r)return t;if("symbol"===r)return `Symbol(${t.description})`;if("function"===r)return `Function ${t.name}(){}`;if(t instanceof String)return t.toString();if(Number.isNaN(t))return "NaN";if(t===1/0)return "Infinity";if(t===-1/0)return "-Infinity";if(t instanceof Error)return `${t.constructor.name}: ${t.message}`;if(t instanceof Promise)return "Promise";if(t instanceof Set)return `Set: ${Z(Array.from(t))}`;if(t instanceof Map)return `Map: ${Z(Array.from(t.entries()))}`;if(t instanceof RegExp)return t.toString();if(Array.isArray(t))return `[${t.map(Z).join(", ")}]`;let e;try{e=JSON.stringify(t);}catch(r){e=t.toString();}return e}new TextDecoder;new TextEncoder;const dt=1e6;var mt={s2ns:1e9,ms2ns:dt,timestamp:function(){if("undefined"!=typeof performance&&"number"==typeof performance.timeOrigin){const t=performance.timeOrigin,r=performance.now();return Math.ceil((t+r)/dt)}return Date.now()},timestamp64:bt,lapseNano:At,lapseMillis:Et,timeoutNano:function(t,r){return At(t)>r},timeoutMillis:function(t,r){return Et(t)>r}};function bt(){if("undefined"!=typeof performance&&"number"==typeof performance.timeOrigin){const t=performance.timeOrigin,r=performance.now();return BigInt((t+r)*dt)}return BigInt(Date.now()*dt)}function At(t,r){return (r??bt())-t}function Et(t,r){r=r??bt();return BigInt(r-t)/BigInt(dt)}
 
 // internal
 // owned
@@ -16,7 +16,7 @@ function a$1(t){return "boolean"==typeof t}function c$1(t){return "function"==ty
  */
 
 // module vars
-const { assertPositive } = C;
+const { assertPositive: assertPositive$2 } = C;
 
 /**
  * A set that has a fixed capacity and automatically removes the oldest element when the capacity is reached.
@@ -31,7 +31,7 @@ class CappedSet {
    * @throws {Error} If capacity is less than or equal to 0
    */
   constructor (capacity) {
-    assertPositive(capacity, 'capacity');
+    assertPositive$2(capacity, 'capacity');
     this.capacity = capacity;
     /**
      * 1. key is the Value stored in CappedSet
@@ -175,7 +175,7 @@ class CappedSet {
   }
 }
 
-var e={isFunction:t,isNil:s};function t(e){return "function"==typeof e}function s(e){return null==e}function n(e){return null!=e&&"string"==typeof e}var r={assertNumber:function(e,t){if(!function(e){return null!=e&&"number"==typeof e}(e))throw new Error(`${t?'"'+t+'" ':""}Not Number: type=${typeof e} value=${i(e)}`)},assertFunction:function(e,s){if(!t(e))throw new Error(`${s?'"'+s+'" ':""}Not Function: type=${typeof e} value=${i(e)}`)},assertNotNil:function(e,t){if(s(e))throw new Error((t?'"'+t+'" ':"")+"Should Not Nil")},assertString:function(e,t){if(!n(e))throw new Error(`${t?'"'+t+'" ':""}Not String: type=${typeof e} value=${i(e)}`)},assertStringOrSymbol:function(e,t){if(!n(e)&&!function(e){return null!=e&&"symbol"==typeof e}(e))throw new Error(`${t?'"'+t+'" ':""}Not String or Symbol: type=${typeof e} value=${i(e)}`)}};function i(e){if(null===e)return "null";if(void 0===e)return "undefined";let t;try{t=JSON.stringify(e);}catch(s){t=e.toString();}return t}new TextDecoder,new TextEncoder;const l="DOwner$#$",{assertFunction:a,assertNotNil:o}=r;class c{constructor(e,t,s=false){o(e,"event"),a(t,"callback"),this._event=e,this._callback=t,this._isOnce=!!s,this._owner=void 0;}set owner(e){this._owner=e;}get owner(){return this._owner===l?void 0:this._owner}get event(){return this._event}get isOnce(){return this._isOnce}isSameCallback(e){return this._callback===e}get callback(){return this._callback}invoke(...e){try{return this._callback(...e)}finally{if(this._isOnce)try{this._event._remove(this);}catch(e){console.warn(e);}}}listener(...e){return this.invoke(...e)}}const{isFunction:h,isNil:u}=e,{assertStringOrSymbol:_,assertFunction:f}=r;class m{static get DefaultOwner(){return l}constructor(e){_(e,"eventName"),this._name=e,this._callbacks=new Set,this._listeners=[],this._callback2Listeners=new Map,this._listener2Owner=new Map,this._owner2Listeners=new Map;}get name(){return this._name}isEmpty(){return 0===this._callbacks.size}rawListeners(){return [...this._listeners]}listenerCount(e){return null==e?this._listeners.length:this._callback2Listeners.get(e)?.size??0}callbacks(){return [...this.rawListeners().map(e=>e.callback)]}emit(...e){if(0===this._listeners.length)return  false;for(const t of [...this._listeners])t.invoke(...e);return  true}emitOwner(e,...t){if(0===this._listeners.length)return  false;const s=this._owner2Listeners.get(e);if(null==s)return  false;for(const e of [...s])e.invoke(...t);return  true}hasListener(e){return !!h(e)&&this._callbacks.has(e)}hasOwner(e){return !u(e)&&this._owner2Listeners.has(e)}addListener(e,t){return this._addListener(e,t,false,false)}prependListener(e,t){return this._addListener(e,t,false,true)}addOnceListener(e,t){return this._addListener(e,t,true,false)}prependOnceListener(e,t){return this._addListener(e,t,true,true)}_addListener(e,t,s,n){if(u(e))return  false;f(e),this._callbacks.has(e)||this._callbacks.add(e),t=t??l;const r=new c(this,e,s);r.owner=t,n?this._listeners.unshift(r):this._listeners.push(r),this._listener2Owner.set(r,t);let i=this._callback2Listeners.get(e);null==i&&(i=new Set,this._callback2Listeners.set(e,i)),i.add(r);let a=this._owner2Listeners.get(t);return null==a&&(a=new Set,this._owner2Listeners.set(t,a)),a.add(r),true}removeListener(e){if(u(e))return  false;if(!this._callbacks.has(e))return  false;this._callbacks.delete(e);const t=this._callback2Listeners.get(e);if(null==t)return  false;this._callback2Listeners.delete(e);for(const e of t){ -1!==this._listeners.indexOf(e)&&this._listeners.splice(this._listeners.indexOf(e),1);const t=this._listener2Owner.get(e);if(null==t)continue;this._listener2Owner.delete(e);const s=this._owner2Listeners.get(t);null!=s&&(s.delete(e),0===s.size&&this._owner2Listeners.delete(t));}return  true}_remove(e){const t=this._listeners.indexOf(e);-1!==t&&this._listeners.splice(t,1);const{callback:s}=e,n=this._callback2Listeners.get(s);null!=n&&(n.delete(e),0===n.size&&(this._callback2Listeners.delete(s),this._callbacks.delete(s)));const r=this._listener2Owner.get(e);if(null==r)return;this._listener2Owner.delete(e);const i=this._owner2Listeners.get(r);null!=i&&(i.delete(e),0===i.size&&this._owner2Listeners.delete(r));}removeAllListeners(e){if(u(e))return this._callbacks.clear(),this._listeners.length=0,this._callback2Listeners.clear(),this._listener2Owner.clear(),this._owner2Listeners.clear(),this;const t=this._owner2Listeners.get(e);if(null==t)return this;this._owner2Listeners.delete(e);for(const e of t){ -1!==this._listeners.indexOf(e)&&this._listeners.splice(this._listeners.indexOf(e),1),this._listener2Owner.delete(e);const{callback:t}=e,s=this._callback2Listeners.get(t);null!=s&&(s.delete(e),0===s.size&&(this._callback2Listeners.delete(t),this._callbacks.delete(t)));}return this}}const{isNil:d}=e,{assertString:w,assertFunction:L,assertNumber:v,assertStringOrSymbol:g,assertNotNil:p}=r,b=["on","once","addListener","prependListener","prependOnceListener","off","offAll","offOwner","removeAllListeners","removeListener","emit","emitOwner","setMaxListeners","getMaxListeners","hasOwner","listeners","listenerCount","eventNames","rawListeners"];let O=10;class k{static mixin(e){const t=new k;e.__emitter=t;for(const s of b){const n=t[s];e[s]=n.bind(t);}return e}static get defaultMaxListeners(){return O}static set defaultMaxListeners(e){v(e),O=e??10;}constructor(){this._name2Event=new Map,this._maxListeners=O;}addListener(e,t,s){return this.on(e,t,s)}prependListener(e,t,s){w(e),L(t),this._checkMaxListeners(e);return this._getOrCreateEvent(e).prependListener(t,s),this}prependOnceListener(e,t,s){w(e),L(t),this._checkMaxListeners(e);return this._getOrCreateEvent(e).prependOnceListener(t,s),this}emit(e,...t){const s=this._name2Event.get(e);return null!=s&&!s.isEmpty()&&(s.emit(...t),true)}emitOwner(e,t,...s){if(null==t)throw new Error('Missing "owner"');const n=this._name2Event.get(e);return null!=n&&!n.isEmpty()&&(n.emitOwner(t,...s),true)}eventNames(){return [...this._name2Event.keys()]}getMaxListeners(){return this._maxListeners}listenerCount(e,t){g(e,"eventName");const s=this._name2Event.get(e);return null==s||s.isEmpty()?0:s.listenerCount(t)}listeners(e){g(e,"eventName");const t=this._name2Event.get(e);return null==t||t.isEmpty()?[]:t.callbacks()}off(e,t){const s=this._name2Event.get(e);return null==s?this:(s.removeListener(t),s.isEmpty()?(this._name2Event.delete(e),this):this)}offAll(e,t){g(e,"eventName");const s=this._name2Event.get(e);return null==s?this:(s.removeAllListeners(t),s.isEmpty()?(this._name2Event.delete(e),this):this)}offOwner(e){p(e,"owner");const t=[...this._name2Event.values()];for(const s of t)s.removeAllListeners(e),s.isEmpty()&&this._name2Event.delete(s.name);return this}on(e,t,s){w(e),L(t),this._checkMaxListeners(e);return this._getOrCreateEvent(e).addListener(t,s),this}_checkMaxListeners(e){let t=0;0!==this._maxListeners&&this._maxListeners!==1/0&&(t=this.listenerCount(e))>=this._maxListeners&&console.warn(`maxlistenersexceededwarning: Possible EventEmitter memory leak detected. ${t} ${e} listeners added to [${this}]. Use emitter.setMaxListeners() to increase limit`);}once(e,t,s){w(e),L(t);return this._getOrCreateEvent(e).addOnceListener(t,s),this}rawListeners(e){return this._name2Event.get(e)?.rawListeners()||[]}removeAllListeners(e,t){return this.offAll(e,t)}removeListener(e,t){return this.off(e,t)}setMaxListeners(e){if(v(e),e<0)throw new RangeError("maxListeners must >=0");return this._maxListeners=e,this}_getOrCreateEvent(e){if(this._name2Event.has(e))return this._name2Event.get(e);const t=new m(e);return this._name2Event.set(e,t),t}hasOwner(e){if(d(e))return  false;for(const t of this._name2Event.values())if(t.hasOwner(e))return  true;return  false}}
+var e={isFunction:t,isNil:n};function t(e){return "function"==typeof e}function n(e){return null==e}function s(e){return null!=e&&"string"==typeof e}var r={assertNumber:function(e,t){if(!function(e){return null!=e&&"number"==typeof e}(e))throw new Error(`${t?'"'+t+'" ':""}Not Number: type=${typeof e} value=${i(e)}`)},assertFunction:function(e,n){if(!t(e))throw new Error(`${n?'"'+n+'" ':""}Not Function: type=${typeof e} value=${i(e)}`)},assertNotNil:function(e,t){if(n(e))throw new Error((t?'"'+t+'" ':"")+"Should Not Nil")},assertString:function(e,t){if(!s(e))throw new Error(`${t?'"'+t+'" ':""}Not String: type=${typeof e} value=${i(e)}`)},assertStringOrSymbol:function(e,t){if(!s(e)&&!function(e){return null!=e&&"symbol"==typeof e}(e))throw new Error(`${t?'"'+t+'" ':""}Not String or Symbol: type=${typeof e} value=${i(e)}`)}};function i(e){if(null===e)return "null";if(void 0===e)return "undefined";const t=typeof e;if("string"===t)return e;if("symbol"===t)return `Symbol(${e.description})`;if("function"===t)return `Function ${e.name}(){}`;if(e instanceof String)return e.toString();if(Number.isNaN(e))return "NaN";if(e===1/0)return "Infinity";if(e===-1/0)return "-Infinity";if(e instanceof Error)return `${e.constructor.name}: ${e.message}`;if(e instanceof Promise)return "Promise";if(e instanceof Set)return `Set: ${i(Array.from(e))}`;if(e instanceof Map)return `Map: ${i(Array.from(e.entries()))}`;if(e instanceof RegExp)return e.toString();if(Array.isArray(e))return `[${e.map(i).join(", ")}]`;let n;try{n=JSON.stringify(e);}catch(t){n=e.toString();}return n}new TextDecoder,new TextEncoder;const l="DOwner$#$",{assertFunction:a,assertNotNil:o}=r;class c{constructor(e,t,n=false){o(e,"event"),a(t,"callback"),this._event=e,this._callback=t,this._isOnce=!!n,this._owner=void 0;}set owner(e){this._owner=e;}get owner(){return this._owner===l?void 0:this._owner}get event(){return this._event}get isOnce(){return this._isOnce}isSameCallback(e){return this._callback===e}get callback(){return this._callback}invoke(...e){try{return this._callback(...e)}finally{if(this._isOnce)try{this._event._remove(this);}catch(e){console.warn(e);}}}listener(...e){return this.invoke(...e)}}const{isFunction:h,isNil:u}=e,{assertStringOrSymbol:_,assertFunction:f}=r;class m{static get DefaultOwner(){return l}constructor(e){_(e,"eventName"),this._name=e,this._callbacks=new Set,this._listeners=[],this._callback2Listeners=new Map,this._listener2Owner=new Map,this._owner2Listeners=new Map;}get name(){return this._name}isEmpty(){return 0===this._callbacks.size}rawListeners(){return [...this._listeners]}listenerCount(e){return null==e?this._listeners.length:this._callback2Listeners.get(e)?.size??0}callbacks(){return [...this.rawListeners().map(e=>e.callback)]}emit(...e){if(0===this._listeners.length)return  false;for(const t of [...this._listeners])t.invoke(...e);return  true}emitOwner(e,...t){if(0===this._listeners.length)return  false;const n=this._owner2Listeners.get(e);if(null==n)return  false;for(const e of [...n])e.invoke(...t);return  true}hasListener(e){return !!h(e)&&this._callbacks.has(e)}hasOwner(e){return !u(e)&&this._owner2Listeners.has(e)}addListener(e,t){return this._addListener(e,t,false,false)}prependListener(e,t){return this._addListener(e,t,false,true)}addOnceListener(e,t){return this._addListener(e,t,true,false)}prependOnceListener(e,t){return this._addListener(e,t,true,true)}_addListener(e,t,n,s){if(u(e))return  false;f(e),this._callbacks.has(e)||this._callbacks.add(e),t=t??l;const r=new c(this,e,n);r.owner=t,s?this._listeners.unshift(r):this._listeners.push(r),this._listener2Owner.set(r,t);let i=this._callback2Listeners.get(e);null==i&&(i=new Set,this._callback2Listeners.set(e,i)),i.add(r);let a=this._owner2Listeners.get(t);return null==a&&(a=new Set,this._owner2Listeners.set(t,a)),a.add(r),true}removeListener(e){if(u(e))return  false;if(!this._callbacks.has(e))return  false;this._callbacks.delete(e);const t=this._callback2Listeners.get(e);if(null==t)return  false;this._callback2Listeners.delete(e);for(const e of t){ -1!==this._listeners.indexOf(e)&&this._listeners.splice(this._listeners.indexOf(e),1);const t=this._listener2Owner.get(e);if(null==t)continue;this._listener2Owner.delete(e);const n=this._owner2Listeners.get(t);null!=n&&(n.delete(e),0===n.size&&this._owner2Listeners.delete(t));}return  true}_remove(e){const t=this._listeners.indexOf(e);-1!==t&&this._listeners.splice(t,1);const{callback:n}=e,s=this._callback2Listeners.get(n);null!=s&&(s.delete(e),0===s.size&&(this._callback2Listeners.delete(n),this._callbacks.delete(n)));const r=this._listener2Owner.get(e);if(null==r)return;this._listener2Owner.delete(e);const i=this._owner2Listeners.get(r);null!=i&&(i.delete(e),0===i.size&&this._owner2Listeners.delete(r));}removeAllListeners(e){if(u(e))return this._callbacks.clear(),this._listeners.length=0,this._callback2Listeners.clear(),this._listener2Owner.clear(),this._owner2Listeners.clear(),this;const t=this._owner2Listeners.get(e);if(null==t)return this;this._owner2Listeners.delete(e);for(const e of t){ -1!==this._listeners.indexOf(e)&&this._listeners.splice(this._listeners.indexOf(e),1),this._listener2Owner.delete(e);const{callback:t}=e,n=this._callback2Listeners.get(t);null!=n&&(n.delete(e),0===n.size&&(this._callback2Listeners.delete(t),this._callbacks.delete(t)));}return this}}const{isNil:d}=e,{assertString:w,assertFunction:L,assertNumber:v,assertStringOrSymbol:g,assertNotNil:p}=r,b=["on","once","addListener","prependListener","prependOnceListener","off","offAll","offOwner","removeAllListeners","removeListener","emit","emitOwner","setMaxListeners","getMaxListeners","hasOwner","listeners","listenerCount","eventNames","rawListeners"];let O=10;class k{static mixin(e){const t=new k;e.__emitter=t;for(const n of b){const s=t[n];e[n]=s.bind(t);}return e}static get defaultMaxListeners(){return O}static set defaultMaxListeners(e){v(e),O=e??10;}constructor(){this._name2Event=new Map,this._maxListeners=O;}addListener(e,t,n){return this.on(e,t,n)}prependListener(e,t,n){w(e),L(t),this._checkMaxListeners(e);return this._getOrCreateEvent(e).prependListener(t,n),this}prependOnceListener(e,t,n){w(e),L(t),this._checkMaxListeners(e);return this._getOrCreateEvent(e).prependOnceListener(t,n),this}emit(e,...t){const n=this._name2Event.get(e);return null!=n&&!n.isEmpty()&&(n.emit(...t),true)}emitOwner(e,t,...n){if(null==t)throw new Error('Missing "owner"');const s=this._name2Event.get(e);return null!=s&&!s.isEmpty()&&(s.emitOwner(t,...n),true)}eventNames(){return [...this._name2Event.keys()]}getMaxListeners(){return this._maxListeners}listenerCount(e,t){g(e,"eventName");const n=this._name2Event.get(e);return null==n||n.isEmpty()?0:n.listenerCount(t)}listeners(e){g(e,"eventName");const t=this._name2Event.get(e);return null==t||t.isEmpty()?[]:t.callbacks()}off(e,t){const n=this._name2Event.get(e);return null==n?this:(n.removeListener(t),n.isEmpty()?(this._name2Event.delete(e),this):this)}offAll(e,t){g(e,"eventName");const n=this._name2Event.get(e);return null==n?this:(n.removeAllListeners(t),n.isEmpty()?(this._name2Event.delete(e),this):this)}offOwner(e){p(e,"owner");const t=[...this._name2Event.values()];for(const n of t)n.removeAllListeners(e),n.isEmpty()&&this._name2Event.delete(n.name);return this}on(e,t,n){w(e),L(t),this._checkMaxListeners(e);return this._getOrCreateEvent(e).addListener(t,n),this}_checkMaxListeners(e){let t=0;0!==this._maxListeners&&this._maxListeners!==1/0&&(t=this.listenerCount(e))>=this._maxListeners&&console.warn(`maxlistenersexceededwarning: Possible EventEmitter memory leak detected. ${t} ${e} listeners added to [${this}]. Use emitter.setMaxListeners() to increase limit`);}once(e,t,n){w(e),L(t);return this._getOrCreateEvent(e).addOnceListener(t,n),this}rawListeners(e){return this._name2Event.get(e)?.rawListeners()||[]}removeAllListeners(e,t){return this.offAll(e,t)}removeListener(e,t){return this.off(e,t)}setMaxListeners(e){if(v(e),e<0)throw new RangeError("maxListeners must >=0");return this._maxListeners=e,this}_getOrCreateEvent(e){if(this._name2Event.has(e))return this._name2Event.get(e);const t=new m(e);return this._name2Event.set(e,t),t}hasOwner(e){if(d(e))return  false;for(const t of this._name2Event.values())if(t.hasOwner(e))return  true;return  false}}
 
 // 3rd
 // internal
@@ -722,10 +722,725 @@ class Hour24TimeWheelCache extends k {
   }
 }
 
-var index = { CappedSet, TimeWheelCache, Hour24TimeWheelCache };
+// internal
+// owned
+
+/**
+ * @typedef {{
+ *   value: any,
+ *   prev: Node|undefined,
+ *   next: Node|undefined
+ * }} Node
+ */
+
+// module vars
+const { assertNotNegative, assertPositive: assertPositive$1 } = C;
+
+/**
+ * A doubly linked list implementation.
+ *
+ * @class LinkedList
+ */
+class LinkedList {
+  /**
+   * Creates a new LinkedList instance.
+   * @constructor
+   */
+  constructor () {
+    /**
+     * @type {Node|undefined}
+     */
+    this._head = undefined;
+    /**
+     * @type {Node|undefined}
+     */
+    this._tail = undefined;
+    /**
+     * @type {number}
+     */
+    this._size = 0;
+  }
+
+  get size () {
+    return this._size
+  }
+
+  /**
+   * get the first element
+   */
+  get first () {
+    return this._head?.value
+  }
+
+  /**
+   * get the last element
+   */
+  get last () {
+    return this._tail?.value
+  }
+
+  [Symbol.iterator] () {
+    let current = this._head;
+    const iterator = {
+      next () {
+        if (current) {
+          const value = current.value;
+          current = current.next;
+          return { value, done: false }
+        }
+        return { value: undefined, done: true }
+      },
+      [Symbol.iterator] () {
+        return this
+      }
+    };
+    return iterator
+  }
+
+  /**
+   * Adds a value to the beginning of the linked list.
+   * @param {*} value - The value to add
+   * @returns {LinkedList} This linked list instance for chaining
+   */
+  addFirst (value) {
+    /**
+     * @type {Node}
+     */
+    const node = { value, prev: undefined, next: this._head };
+
+    if (this._head) {
+      this._head.prev = node;
+    } else {
+      this._tail = node;
+    }
+
+    this._head = node;
+    this._size++;
+    return this
+  }
+
+  /**
+   * Adds a value to the end of the linked list.
+   * @param {*} value - The value to add
+   * @returns {LinkedList} This linked list instance for chaining
+   */
+  addLast (value) {
+    /**
+     * @type {Node}
+     */
+    const node = { value, prev: this._tail, next: undefined };
+
+    if (this._tail) {
+      this._tail.next = node;
+    } else {
+      this._head = node;
+    }
+
+    this._tail = node;
+    this._size++;
+    return this
+  }
+
+  /**
+   * Adds a value to the end of the linked list.
+   * @param {*} value - The value to add
+   * @returns {LinkedList} This linked list instance for chaining
+   */
+  add (value) {
+    return this.addLast(value)
+  }
+
+  /**
+   * Removes and returns the first element from the linked list.
+   * @returns {*} The removed value, or undefined if the list is empty
+   */
+  removeFirst () {
+    if (!this._head) {
+      return undefined
+    }
+
+    const value = this._head.value;
+    this._head = this._head.next;
+
+    if (this._head) {
+      this._head.prev = undefined;
+    } else {
+      this._tail = undefined;
+    }
+
+    this._size--;
+    return value
+  }
+
+  /**
+   * Removes and returns the last element from the linked list.
+   * @returns {*} The removed value, or undefined if the list is empty
+   */
+  removeLast () {
+    if (!this._tail) {
+      return undefined
+    }
+
+    const value = this._tail.value;
+    this._tail = this._tail.prev;
+
+    if (this._tail) {
+      this._tail.next = undefined;
+    } else {
+      this._head = undefined;
+    }
+
+    this._size--;
+    return value
+  }
+
+  /**
+   * Removes the first occurrence of the specified value from the linked list.
+   * @param {*} value - The value to remove
+   * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+   * @returns {boolean} True if the value was found and removed, false otherwise
+   */
+  remove (value, comparator) {
+    const compare = comparator || this._defaultComparator;
+    let current = this._head;
+
+    while (current) {
+      if (compare(current.value, value)) {
+        this._removeNode(current);
+        return true
+      }
+      current = current.next;
+    }
+
+    return false
+  }
+
+  /**
+   * Removes all occurrences of the specified value from the linked list.
+   * @param {*} value - The value to remove
+   * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+   * @returns {number} The number of elements removed
+   */
+  removeAll (value, comparator) {
+    const compare = comparator || this._defaultComparator;
+    let removedCount = 0;
+    let current = this._head;
+
+    while (current) {
+      const next = current.next; // Store next before potential removal
+      if (compare(current.value, value)) {
+        this._removeNode(current);
+        removedCount++;
+      }
+      current = next;
+    }
+
+    return removedCount
+  }
+
+  /**
+   * Removes the element at the specified index.
+   * @param {number} index - The index of the element to remove
+   * @returns {*} The removed value, or undefined if index is out of bounds
+   */
+  removeAt (index) {
+    assertNotNegative(index, 'index');
+
+    if (index >= this._size) {
+      return undefined
+    }
+
+    if (index === 0) {
+      return this.removeFirst()
+    }
+
+    if (index === this._size - 1) {
+      return this.removeLast()
+    }
+
+    let current = this._head;
+    for (let i = 0; i < index; i++) {
+      current = current?.next;
+    }
+
+    if (current) {
+      const value = current.value;
+      this._removeNode(current);
+      return value
+    }
+
+    return undefined
+  }
+
+  /**
+   * Remove speicied count elements from head
+   * @param {number} count - The count of elements to remove
+   * @returns {boolean} True if any element was removed, false otherwise
+   */
+  removeFromHead (count) {
+    assertPositive$1(count, 'count');
+
+    // do nothing, it list is empty
+    if (this._size === 0) {
+      return false
+    }
+
+    // beyond size, remove all elements
+    if (count >= this._size) {
+      this.clear();
+      return true
+    }
+
+    // Find the node at the specified index
+    let current = this._head;
+    for (let i = 1; i < count; i++) {
+      if (!current) {
+        return false
+      }
+      current = current.next;
+    }
+    // Remove the nodes
+    if (current) {
+      if (current.next) {
+        this._head = current.next;
+        this._head.prev = undefined;
+      } else {
+        this._head = undefined;
+        this._tail = undefined;
+      }
+      this._size = this._size - count;
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Remove specified count elements from tail
+   * @param {number} count - The count of elements to remove
+   * @returns {boolean} True if any element was removed, false otherwise
+   */
+  removeFromTail (count) {
+    assertPositive$1(count, 'count');
+
+    // do nothing, if list is empty
+    if (this._size === 0) {
+      return false
+    }
+
+    // beyond size, remove all elements
+    if (count >= this._size) {
+      this.clear();
+      return true
+    }
+
+    // Find the node at the specified position from tail
+    let current = this._tail;
+    for (let i = 1; i < count; i++) {
+      if (!current) {
+        return false
+      }
+      current = current.prev;
+    }
+    // Remove the nodes
+    if (current) {
+      if (current.prev) {
+        this._tail = current.prev;
+        this._tail.next = undefined;
+      } else {
+        this._head = undefined;
+        this._tail = undefined;
+      }
+      this._size = this._size - count;
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Checks if the linked list contains the specified value.
+   * @param {*} value - The value to check for
+   * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+   * @returns {boolean} True if the value exists, false otherwise
+   */
+  contains (value, comparator) {
+    const compare = comparator || this._defaultComparator;
+    let current = this._head;
+    while (current) {
+      if (compare(current.value, value)) {
+        return true
+      }
+      current = current.next;
+    }
+    return false
+  }
+
+  /**
+   * Returns the index of the first occurrence of the specified value.
+   * @param {*} value - The value to find
+   * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+   * @returns {number} The index of the value, or -1 if not found
+   */
+  indexOf (value, comparator) {
+    const compare = comparator || this._defaultComparator;
+    let current = this._head;
+    let index = 0;
+    while (current) {
+      if (compare(current.value, value)) {
+        return index
+      }
+      current = current.next;
+      index++;
+    }
+    return -1
+  }
+
+  /**
+   * Returns the index of the last occurrence of the specified value.
+   * @param {*} value - The value to find
+   * @param {function(*, *): boolean} [comparator] - Optional comparison function (a, b) => boolean
+   * @returns {number} The index of the last occurrence, or -1 if not found
+   */
+  indexLastOf (value, comparator) {
+    const compare = comparator || this._defaultComparator;
+    let current = this._tail;
+    let index = this._size - 1;
+    while (current) {
+      if (compare(current.value, value)) {
+        return index
+      }
+      current = current.prev;
+      index--;
+    }
+    return -1
+  }
+
+  /**
+   * Gets the value at the specified index.
+   * @param {number} index - The index of the value to get
+   * @returns {*} The value at the index, or undefined if index is out of bounds
+   */
+  get (index) {
+    assertNotNegative(index, 'index');
+
+    if (index >= this._size) {
+      return undefined
+    }
+
+    let current = this._head;
+    for (let i = 0; i < index; i++) {
+      current = current?.next;
+    }
+
+    return current?.value
+  }
+
+  /**
+   * Inserts a value at the specified index.
+   * @param {number} index - The index at which to insert the value
+   * @param {*} value - The value to insert
+   * @returns {LinkedList} This linked list instance for chaining
+   */
+  insertAt (index, value) {
+    assertNotNegative(index, 'index');
+
+    if (index === 0) {
+      return this.addFirst(value)
+    }
+
+    if (index >= this._size) {
+      return this.addLast(value)
+    }
+
+    let current = this._head;
+    for (let i = 0; i < index - 1; i++) {
+      current = current?.next;
+    }
+
+    if (current) {
+      /**
+       * @type {Node}
+       */
+      const node = { value, prev: current, next: current.next };
+      if (current.next) {
+        current.next.prev = node;
+      }
+      current.next = node;
+      this._size++;
+    }
+
+    return this
+  }
+
+  /**
+   * Removes all elements from the linked list.
+   */
+  clear () {
+    this._head = undefined;
+    this._tail = undefined;
+    this._size = 0;
+  }
+
+  /**
+   * Returns an array containing all the values in the linked list.
+   * @returns {any[]} An array of all values
+   */
+  toArray () {
+    const result = [];
+    let current = this._head;
+    while (current) {
+      result.push(current.value);
+      current = current.next;
+    }
+    return result
+  }
+
+  /**
+   * Returns an iterator of the values in the linked list.
+   * @returns {Iterator<any>} An iterator object that yields the values of the linked list
+   */
+  values () {
+    return this[Symbol.iterator]()
+  }
+
+  /**
+   * Returns a slice of the linked list as an array.
+   * @param {number} [start=0] - The start index (inclusive). If negative, counts from the end.
+   * @param {number} [end=this.size] - The end index (exclusive). If negative, counts from the end.
+   * @returns {any[]} An array containing the sliced elements
+   */
+  slice (start = 0, end = this.size) {
+    // Handle negative indices
+    const normalizedStart = start < 0 ? Math.max(this.size + start, 0) : Math.min(start, this.size);
+    const normalizedEnd = end < 0 ? Math.max(this.size + end, 0) : Math.min(end, this.size);
+
+    if (normalizedStart >= normalizedEnd) {
+      return []
+    }
+
+    if (start < 0) {
+      return this._sliceNegative(normalizedStart, normalizedEnd)
+    } else {
+      return this._slicePositive(normalizedStart, normalizedEnd)
+    }
+  }
+
+  /**
+   * Returns a string representation of the FixedLinkedList.
+   * @returns {string} String representation
+   */
+  toString () {
+    const partialElements = this.slice(0, 3);
+    const partialString = this.size > 3 ? G.safeToString(partialElements) + '...' : G.safeToString(partialElements);
+    return `LinkedList[${this.size}](${partialString})`
+  }
+
+  /**
+   * Slice implementation for positive indices (iterates from head to tail)
+   * @param {number} start - Normalized start index (inclusive)
+   * @param {number} end - Normalized end index (exclusive)
+   * @returns {any[]} An array containing the sliced elements
+   * @private
+   */
+  _slicePositive (start, end) {
+    const result = [];
+    let current = this._head;
+    let index = 0;
+
+    // Move to the starting position
+    while (current && index < start) {
+      current = current.next;
+      index++;
+    }
+
+    // Collect elements from start to end
+    while (current && index < end) {
+      result.push(current.value);
+      current = current.next;
+      index++;
+    }
+
+    return result
+  }
+
+  /**
+   * Slice implementation for negative indices (iterates from tail to head)
+   * @param {number} start - Normalized start index (inclusive)
+   * @param {number} end - Normalized end index (exclusive)
+   * @returns {any[]} An array containing the sliced elements
+   * @private
+   */
+  _sliceNegative (start, end) {
+    const result = [];
+    let current = this._tail;
+    let index = this.size - 1;
+
+    // Move to the starting position
+    while (current && index > start) {
+      current = current.prev;
+      index--;
+    }
+
+    // Collect elements from start to end
+    while (current && index < end) {
+      result.push(current.value);
+      current = current.next;
+      index++;
+    }
+
+    return result
+  }
+
+  /**
+   * Removes a node from the linked list.
+   * @param {Node} node - The node to be removed
+   * @private
+   */
+  _removeNode (node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this._head = node.next;
+    }
+
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this._tail = node.prev;
+    }
+
+    this._size--;
+  }
+
+  /**
+   * Default comparator for strict equality comparison.
+   * @param {*} a - First value to compare
+   * @param {*} b - Second value to compare
+   * @returns {boolean} True if values are strictly equal
+   * @private
+   */
+  _defaultComparator (a, b) {
+    return a === b
+  }
+}
+
+// internal
+// owned
+
+// module vars
+const { assertPositive } = C;
+
+/**
+ * A fixed-capacity linked list that automatically removes elements when capacity is exceeded.
+ * When adding to the end (addLast), it removes the first element if capacity is full.
+ * When adding to the beginning (addFirst), it removes the last element if capacity is full.
+ *
+ * @class FixedLinkedList
+ * @extends LinkedList
+ */
+class FixedLinkedList extends LinkedList {
+  /**
+   * Creates a new FixedLinkedList instance with a fixed capacity.
+   * @constructor
+   * @param {number} capacity - The maximum number of elements the list can hold (must be > 0)
+   * @throws {Error} If capacity is less than or equal to 0
+   */
+  constructor (capacity) {
+    assertPositive(capacity, 'capacity');
+    super();
+    this.capacity = Math.ceil(capacity);
+  }
+
+  /**
+   * Adds a value to the beginning of the linked list.
+   * If the list is at capacity, removes the last element before adding.
+   * @param {*} value - The value to add
+   * @returns {FixedLinkedList} This linked list instance for chaining
+   */
+  addFirst (value) {
+    if (this.size >= this.capacity) {
+      this.removeLast();
+    }
+    super.addFirst(value);
+    return this
+  }
+
+  /**
+   * Adds a value to the end of the linked list.
+   * If the list is at capacity, removes the first element before adding.
+   * @param {*} value - The value to add
+   * @returns {FixedLinkedList} This linked list instance for chaining
+   */
+  addLast (value) {
+    if (this.size >= this.capacity) {
+      this.removeFirst();
+    }
+    super.addLast(value);
+    return this
+  }
+
+  /**
+   * Adds a value to the end of the linked list.
+   * If the list is at capacity, removes the first element before adding.
+   * @param {*} value - The value to add
+   * @returns {FixedLinkedList} This linked list instance for chaining
+   */
+  add (value) {
+    return this.addLast(value)
+  }
+
+  /**
+   * Inserts a value at the specified index.
+   * If the list is at capacity and index is not at the end, removes the first element before adding.
+   * If the list is at capacity and index is at the end, removes the first element before adding.
+   * @param {number} index - The index at which to insert the value
+   * @param {*} value - The value to insert
+   * @returns {FixedLinkedList} This linked list instance for chaining
+   */
+  insertAt (index, value) {
+    // Remove an element if we're at capacity and not adding beyond current size
+    if (this.size >= this.capacity) {
+      // Always remove first element to maintain capacity
+      this.removeFirst();
+    }
+    super.insertAt(index, value);
+    return this
+  }
+
+  /**
+   * Returns the remaining capacity of the list.
+   * @returns {number} The number of additional elements that can be added
+   */
+  get remainingCapacity () {
+    return this.capacity - this.size
+  }
+
+  /**
+   * Checks if the list is at full capacity.
+   * @returns {boolean} True if the list is full, false otherwise
+   */
+  get isFull () {
+    return this.size >= this.capacity
+  }
+
+  /**
+   * Returns a string representation of the FixedLinkedList.
+   * @returns {string} String representation
+   */
+  toString () {
+    const partialElements = this.slice(0, 3);
+    const partialString = this.size > 3 ? G.safeToString(partialElements) + '...' : G.safeToString(partialElements);
+    return `FixedLinkedList[${this.size}/${this.capacity}](${partialString})`
+  }
+}
+
+var index = { CappedSet, TimeWheelCache, Hour24TimeWheelCache, LinkedList, FixedLinkedList };
 
 exports.CappedSet = CappedSet;
+exports.FixedLinkedList = FixedLinkedList;
 exports.Hour24TimeWheelCache = Hour24TimeWheelCache;
+exports.LinkedList = LinkedList;
 exports.TimeWheelCache = TimeWheelCache;
 exports.default = index;
 //# sourceMappingURL=index-dev.cjs.map