@t007/utils 0.0.33 → 0.0.35

package/dist/index.cjs

@@ -21,17 +21,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   INTERACTIVE_SELECTOR: () => INTERACTIVE_SELECTOR,
-  NIL: () => import_sia_reactor.NIL,
-  NOOP: () => import_sia_reactor.NOOP,
+  KEYS_BLOCKS: () => import_utils6.KEYS_BLOCKS,
+  NIL: () => import_sia_reactor2.NIL,
+  NOOP: () => import_sia_reactor2.NOOP,
+  RAFLoop: () => RAFLoop,
   VIRTUAL_RESOURCE: () => VIRTUAL_RESOURCE,
   assignEl: () => import_utils.assignEl,
   bindAllMethods: () => import_utils7.bindAllMethods,
   bindCleanupToSignal: () => bindCleanupToSignal,
   breath: () => breath,
+  camelize: () => camelize,
+  cancelRAFLoop: () => cancelRAFLoop,
+  capitalize: () => capitalize,
   clamp: () => import_utils4.clamp,
   cleanKeyCombo: () => import_utils6.cleanKeyCombo,
   cleanURL: () => cleanURL,
   createEl: () => import_utils.createEl,
+  createListRenderer: () => createListRenderer,
+  debounce: () => debounce,
   deepBreath: () => deepBreath,
   formatKeyForDisplay: () => import_utils6.formatKeyForDisplay,
   formatKeyShortcutsForDisplay: () => import_utils6.formatKeyShortcutsForDisplay,
@@ -57,6 +64,7 @@ __export(index_exports, {
   keyEventAllowed: () => import_utils6.keyEventAllowed,
   limited: () => limited,
   loadResource: () => loadResource,
+  longestIncreasingSubsequence: () => longestIncreasingSubsequence,
   matchKeys: () => import_utils6.matchKeys,
   mockAsync: () => mockAsync,
   onAllMethods: () => import_utils7.onAllMethods,
@@ -70,49 +78,90 @@ __export(index_exports, {
   setInterval: () => import_utils5.setInterval,
   setTimeout: () => import_utils5.setTimeout,
   stringifyKeyEvent: () => import_utils6.stringifyKeyEvent,
-  uid: () => uid
+  throttle: () => throttle,
+  uid: () => uid,
+  uncamelize: () => uncamelize
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/ts/core/dom.ts
 var import_utils = require("sia-reactor/utils");
 var import_utils2 = require("sia-reactor/utils");
-var INTERACTIVE_SELECTOR = ":is(button,[href],input:not([type='hidden']),select,textarea,details>summary,[contenteditable='true'],iframe,audio[controls],video[controls],[tabindex]):not([disabled],[tabindex='-1'],[data-focus-guard],[inert],[inert] *)";
+var import_sia_reactor = require("sia-reactor");
+var INTERACTIVE_SELECTOR = ":is(button,[href],input:not([type='hidden']),select,textarea,details>summary,[contenteditable],iframe,audio[controls],video[controls],[tabindex]):not([disabled],[tabindex='-1'],[data-focus-guard],[inert],[inert] *)";
 var isInteractive = (target) => target instanceof HTMLElement && target.matches(INTERACTIVE_SELECTOR);
 var VIRTUAL_RESOURCE = /* @__PURE__ */ Symbol.for("T007_VIRTUAL_RESOURCE");
-function loadResource(req, type = "style", { module: module2, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, attempts = 3, retryKey = false } = {}, w = window) {
-  w.t007 ??= {}, w.t007._resourceCache ??= {};
+function loadResource(req, type = "style", { module: module2, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, attempts = 3, retryKey = false } = {}, win = window) {
+  win.t007 ??= {}, win.t007._resourceCache ??= {};
   if (req === VIRTUAL_RESOURCE || isSym(req)) return Promise.resolve();
   const src = req;
-  if (w.t007._resourceCache[src]) return w.t007._resourceCache[src];
-  const existing = type === "script" ? Array.prototype.find.call(w.document.scripts, (s) => isSameURL(s.src, src)) : type === "style" ? Array.prototype.find.call(w.document.styleSheets, (s) => isSameURL(s.href, src)) : null;
-  if (existing) return w.t007._resourceCache[src] = Promise.resolve(existing);
-  w.t007._resourceCache[src] = new Promise((resolve, reject) => {
+  if (win.t007._resourceCache[src]) return win.t007._resourceCache[src];
+  const existing = type === "script" ? Array.prototype.find.call(win.document.scripts, (s) => isSameURL(s.src, src)) : type === "style" ? Array.prototype.find.call(win.document.styleSheets, (s) => isSameURL(s.href, src)) : null;
+  if (existing) return win.t007._resourceCache[src] = Promise.resolve(existing);
+  win.t007._resourceCache[src] = new Promise((resolve, reject) => {
     (function tryLoad(remaining, el) {
       const onerror = () => {
         el?.remove?.();
         if (remaining > 1) {
           setTimeout(tryLoad, 1e3, remaining - 1);
-          console.warn(`Retrying ${type} load (${attempts - remaining + 1}): ${src}...`);
+          console.warn(`Retrying ${type} load for "${src}" (${attempts - remaining + 1})...`);
         } else {
-          delete w.t007._resourceCache[src];
-          reject(new Error(`${type} load failed after ${attempts} attempts: ${src}`));
+          delete win.t007._resourceCache[src];
+          reject(new Error(`${capitalize(type)} load failed for "${src}" after ${attempts - 1} attempts`));
         }
       };
       const url = retryKey && remaining < attempts ? `${src}${src.includes("?") ? "&" : "?"}_${retryKey}=${Date.now()}` : src;
-      if (type === "script") w.document.body.append(el = (0, import_utils.createEl)("script", { src: url, type: module2 ? "module" : "text/javascript", crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
-      else if (type === "style") w.document.head.append(el = (0, import_utils.createEl)("link", { rel: "stylesheet", href: url, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
+      if (type === "script") win.document.body.append(el = (0, import_utils.createEl)("script", { src: url, type: module2 ? "module" : "text/javascript", crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
+      else if (type === "style") win.document.head.append(el = (0, import_utils.createEl)("link", { rel: "stylesheet", href: url, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, onload: () => resolve(el), onerror }) || "");
       else reject(new Error(`Unsupported resource type: ${type}`));
     })(attempts);
   });
-  return w.t007._resourceCache[src];
+  return win.t007._resourceCache[src];
 }
 function getWindow(el = window) {
-  return (el instanceof Window ? el : el instanceof Document ? el?.defaultView : el?.ownerDocument?.defaultView) ?? void 0;
+  return el?.ownerDocument?.defaultView ?? el?.defaultView ?? window;
+}
+function createListRenderer({ container, getKey, createNode, updateNode = import_sia_reactor.NOOP, destroyNode = import_sia_reactor.NOOP, initNode }) {
+  let nodeRegistry = /* @__PURE__ */ new Map();
+  if (initNode) {
+    const children = Array.from(container.children);
+    for (let i = 0, len = children.length; i < len; i++) initNode(children[i], (key) => nodeRegistry.set(key, children[i]));
+  }
+  return function syncDOM(array, strict = true) {
+    const newRegistry = /* @__PURE__ */ new Map(), seenKeys = /* @__PURE__ */ new Set(), oldPositions = /* @__PURE__ */ new WeakMap(), children = Array.from(container.children);
+    for (let i = 0, len = children.length; i < len; i++) oldPositions.set(children[i], i);
+    const futureNodes = [], oldIndices = [];
+    for (let i = 0, len = array.length; i < len; i++) {
+      const item = array[i], key = getKey(item);
+      if (seenKeys.has(key)) throw new Error(`[List Renderer] Duplicate key "${key}" detected`);
+      let node = nodeRegistry.get(key);
+      if (!node) {
+        node = createNode(item);
+        if (!node) {
+          if (strict) throw new Error(`[List Renderer] No HTMLElement for key "${key}"`);
+          continue;
+        }
+        oldIndices.push(-1);
+      } else updateNode(node, item), oldIndices.push(oldPositions.get(node) ?? -1);
+      seenKeys.add(key), futureNodes.push(node), newRegistry.set(key, node);
+    }
+    for (const [key, node] of nodeRegistry.entries()) !seenKeys.has(key) && node.parentElement === container && (destroyNode(node, key), node.remove());
+    const sequence = longestIncreasingSubsequence(oldIndices), stable = new Set(sequence);
+    let anchor = null;
+    for (let i = futureNodes.length - 1; i >= 0; i--) {
+      const node = futureNodes[i];
+      if (oldIndices[i] !== -1 && stable.has(i)) {
+        anchor = node;
+        continue;
+      }
+      container.insertBefore(node, anchor), anchor = node;
+    }
+    nodeRegistry = newRegistry;
+  };
 }
 
 // src/ts/index.ts
-var import_sia_reactor = require("sia-reactor");
+var import_sia_reactor2 = require("sia-reactor");
 
 // src/ts/core/obj.ts
 var import_utils3 = require("sia-reactor/utils");
@@ -149,11 +198,42 @@ function inBoolArrOpt(opt, str) {
 
 // src/ts/core/num.ts
 var import_utils4 = require("sia-reactor/utils");
+function longestIncreasingSubsequence(array) {
+  const n = array.length, parent = new Array(n), tails = [];
+  for (let i = 0; i < n; i++) {
+    const value = array[i];
+    if (value === -1) continue;
+    let left = 0;
+    let right = tails.length;
+    while (left < right) {
+      const mid = left + right >> 1;
+      if (array[tails[mid]] < value) left = mid + 1;
+      else right = mid;
+    }
+    if (left > 0) parent[i] = tails[left - 1];
+    else parent[i] = -1;
+    tails[left] = i;
+  }
+  if (!tails.length) return [];
+  const result = [];
+  let k = tails[tails.length - 1];
+  while (k >= 0) result.push(k), k = parent[k];
+  return result.reverse(), result;
+}
 
 // src/ts/core/str.ts
 function uid(prefix = "") {
   return prefix + Date.now().toString(36) + "_" + performance.now().toString(36).replace(".", "") + "_" + Math.random().toString(36).slice(2);
 }
+function capitalize(word = "") {
+  return word.replace(/^(\s*)([a-z])/i, (_, s, l) => s + l.toUpperCase());
+}
+function camelize(str = "", { source } = /[\s_-]+/, { preserveInnerCase: pIC = true, upperFirst: uF = false } = {}) {
+  return (pIC ? str : str.toLowerCase()).replace(new RegExp(source + "(\\w)", "g"), (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c[uF ? "toUpperCase" : "toLowerCase"]());
+}
+function uncamelize(str, separator = " ") {
+  return str.replace(/([a-z])([A-Z])/g, `$1${separator}$2`).toLowerCase();
+}
 function remToPx(rem, el = document.documentElement) {
   return rem * parseFloat(getComputedStyle(el).fontSize);
 }
@@ -175,26 +255,57 @@ function cleanURL(url) {
   }
 }
 function isSameURL(url1, url2) {
+  if (url1 === url2) return true;
   if (!isStr(url1) || !isStr(url2) || !url1 || !url2) return false;
   return cleanURL(url1) === cleanURL(url2);
 }
 
 // src/ts/core/fn.ts
 var import_utils5 = require("sia-reactor/utils");
+function throttle(key, fn, delay = 30, strict = true, signal, win) {
+  const throttleMap = t007._throttlers ??= /* @__PURE__ */ new Map();
+  if (strict === true) {
+    const now = performance.now();
+    return now - (throttleMap.get(key) ?? 0) < delay ? void 0 : (throttleMap.set(key, now), fn());
+  }
+  if (throttleMap.has(key)) return;
+  const id = strict === false ? (0, import_utils5.setTimeout)(() => throttleMap.delete(key), delay, signal, win) : strict(() => throttleMap.delete(key));
+  return throttleMap.set(key, id), fn();
+}
+function debounce(key, fn, delay = 30, strict = true, signal, win) {
+  const debounceMap = t007._debouncers ??= /* @__PURE__ */ new Map();
+  if (strict) {
+    const now = performance.now(), prev = debounceMap.get(key) ?? 0;
+    return debounceMap.set(key, now), now - prev < delay ? void 0 : fn();
+  }
+  const prevId = debounceMap.get(key);
+  prevId !== void 0 && (win ?? window).clearTimeout(prevId);
+  const id = (0, import_utils5.setTimeout)(() => (debounceMap.delete(key), fn()), delay, signal, win);
+  return void debounceMap.set(key, id);
+}
+function RAFLoop(key, fn, signal, win) {
+  const rafLoopMap = t007._RAFLoopers ??= /* @__PURE__ */ new Map();
+  if (rafLoopMap.has(key)) return void rafLoopMap.set(key, fn);
+  rafLoopMap.set(key, fn);
+  const loop = (_ = 0, fn2 = rafLoopMap.get(key)) => fn2 && (fn2(), (0, import_utils5.requestAnimationFrame)(loop, signal, win));
+  loop();
+}
+var cancelRAFLoop = (key) => t007._RAFLoopers ? t007._RAFLoopers.delete(key) : false;
 function limited(FN_KEY, fn, opts = {}) {
-  let count = 0, { key, maxTimes: max = 1 } = isStr(opts) ? { key: opts } : opts;
+  let count = 0, { key, maxTimes: max = 1, oncePerSession = true } = isStr(opts) ? { key: opts } : opts;
   const getReg = () => JSON.parse(localStorage.getItem(FN_KEY) || "{}"), setReg = (r) => localStorage.setItem(FN_KEY, JSON.stringify(r));
   const handle = (...args) => {
+    if (oncePerSession && count > 0) return void 0;
     if (!key) return count++ < max ? fn(...args) : void 0;
     const r = getReg(), c = r[key] || 0;
-    return c < max ? (r[key] = c + 1, setReg(r), fn(...args)) : void 0;
+    return c < max ? (count++, r[key] = c + 1, setReg(r), fn(...args)) : void 0;
   };
   handle.left = max - (handle.count = count);
   handle.reset = () => (count = 0, key && ((r) => (delete r[key], setReg(r)))(getReg()));
   handle.block = () => (count = max, key && ((r) => (r[key] = max, setReg(r)))(getReg()));
   return handle;
 }
-var mockAsync = (timeout = 250) => new Promise((resolve) => setTimeout(resolve, timeout));
+var mockAsync = (timeout = 250) => new Promise((resolve) => (0, import_utils5.setTimeout)(resolve, timeout));
 var breath = (w = window) => new Promise((res) => w.requestAnimationFrame(res));
 var deepBreath = (w = window) => new Promise((res) => w.requestAnimationFrame(() => w.requestAnimationFrame(res)));
 function bindCleanupToSignal(cleanup, signal) {
@@ -229,17 +340,24 @@ if ("undefined" !== typeof window) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   INTERACTIVE_SELECTOR,
+  KEYS_BLOCKS,
   NIL,
   NOOP,
+  RAFLoop,
   VIRTUAL_RESOURCE,
   assignEl,
   bindAllMethods,
   bindCleanupToSignal,
   breath,
+  camelize,
+  cancelRAFLoop,
+  capitalize,
   clamp,
   cleanKeyCombo,
   cleanURL,
   createEl,
+  createListRenderer,
+  debounce,
   deepBreath,
   formatKeyForDisplay,
   formatKeyShortcutsForDisplay,
@@ -265,6 +383,7 @@ if ("undefined" !== typeof window) {
   keyEventAllowed,
   limited,
   loadResource,
+  longestIncreasingSubsequence,
   matchKeys,
   mockAsync,
   onAllMethods,
@@ -278,5 +397,7 @@ if ("undefined" !== typeof window) {
   setInterval,
   setTimeout,
   stringifyKeyEvent,
-  uid
+  throttle,
+  uid,
+  uncamelize
 });

package/dist/index.d.cts

@@ -1,19 +1,22 @@
-import { A as ArrowNavigationHandle } from './arrowNavigation-DK8mqVOk.cjs';
-import { S as ScrollAssistHandle } from './scrollAssist-y9wFmYgt.cjs';
+import { A as ArrowNavigationHandle } from './arrowNavigation-zEJbo8Er.cjs';
+import { F as FocusTrapHandle, S as ScrollAssistHandle } from './scrollAssist-BNvPnsJq.cjs';
 export { NIL, NOOP } from 'sia-reactor';
-export { KeyStruct, assignEl, bindAllMethods, clamp, cleanKeyCombo, createEl, formatKeyForDisplay, formatKeyShortcutsForDisplay, getActiveEl, getTermsForKey, guardAllMethods, guardMethod, isObj, keyEventAllowed, keysSettings, matchKeys, onAllMethods, parseForARIAKS, parseKeyCombo, requestAnimationFrame, setInterval, setTimeout, stringifyKeyEvent } from 'sia-reactor/utils';
+export { KEYS_BLOCKS, KeyStruct, KeysSettings, assignEl, bindAllMethods, clamp, cleanKeyCombo, createEl, formatKeyForDisplay, formatKeyShortcutsForDisplay, getActiveEl, getTermsForKey, guardAllMethods, guardMethod, isObj, keyEventAllowed, matchKeys, onAllMethods, parseForARIAKS, parseKeyCombo, requestAnimationFrame, setInterval, setTimeout, stringifyKeyEvent } from 'sia-reactor/utils';
 
 declare global {
   interface T007Namespace {
     /** Symbol used to mark virtual resources that should not load a real asset. */
     VIRTUAL_RESOURCE: symbol;
     _resourceCache: Partial<Record<string, Promise<HTMLElement | void>>>;
-    _ftrappers?: WeakMap<HTMLElement, () => void>;
+    _throttlers?: Map<string, number>;
+    _debouncers?: Map<string, number>;
+    _RAFLoopers?: Map<string, Function>;
+    _ftrappers?: WeakMap<HTMLElement, FocusTrapHandle>;
     _outsiders?: WeakMap<HTMLElement, () => void>;
     _arrownavs?: WeakMap<HTMLElement, ArrowNavigationHandle>;
     _scrollers?: WeakMap<HTMLElement, ScrollAssistHandle>;
-    _ftrappers_stacks?: WeakMap<EventTarget, HTMLElement[]>;
-    _outsiders_stacks?: WeakMap<EventTarget, HTMLElement[]>;
+    _ftrappers_stack?: HTMLElement[];
+    _outsiders_stack?: HTMLElement[];
     _scrollers_r_observer?: ResizeObserver;
     _scrollers_m_observer?: MutationObserver;
   }
@@ -37,6 +40,27 @@ declare global {
   var t007: T007Namespace;
 }
 
+type TitleCase<S extends string> = S extends `${infer First}${infer Rest}`
+  ? `${Uppercase<First>}${Rest}`
+  : S;
+
+type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}`
+  ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
+  : S extends `${infer P1}-${infer P2}${infer P3}`
+  ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
+  : S extends `${infer P1} ${infer P2}${infer P3}`
+  ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}`
+  : Lowercase<S>;
+
+type NoCamelCase<
+  S extends string,
+  Sep extends string = " "
+> = S extends `${infer First}${infer Rest}`
+  ? First extends Uppercase<First>
+    ? `${Sep}${Lowercase<First>}${NoCamelCase<Rest, Sep>}`
+    : `${First}${NoCamelCase<Rest, Sep>}`
+  : S;
+
 declare function isDef(val: any): boolean;
 declare function isSym<T extends symbol = symbol>(val: any): val is T;
 declare function isBool<T extends boolean = boolean>(val: any): val is T;
@@ -49,20 +73,52 @@ declare function isIter<T = unknown>(obj: any): obj is Iterable<T>;
 declare function isFunc<T extends Function = Function>(val: any): val is T;
 declare function inBoolArrOpt(opt: any, str: string): boolean;
 
+/**
+ * Finds the longest increasing subsequence in an array of numbers.
+ * @param array The input array of numbers
+ * @returns An array of indices representing the longest increasing subsequence
+ */
+declare function longestIncreasingSubsequence(array: number[]): number[];
+
 /** Create a short unique string with an optional prefix.
  * @param prefix Prefix added to the generated id.
  * @returns A browser-safe unique id string.
  */
 declare function uid(prefix?: string): string;
+/** Capitalize the first letter of a string, leaving the rest unchanged.
+ * @param word The string to capitalize.
+ * @returns The input string with the first letter capitalized.
+ */
+declare function capitalize<T extends string>(word?: T): TitleCase<T>;
+/** Convert a string to camelCase by removing separators and capitalizing subsequent words.
+ * @param str The input string to convert.
+ * @param options.source A regex or string defining word separators. @default  whitespace, underscores, and hyphens (`[\s_-]+`).
+ * @param options.preserveInnerCase If true, preserves the original casing of letters; if false, converts the entire string to lowercase before processing. @default  `true`.
+ * @param options.upperFirst If true, capitalizes the first letter of the resulting string (PascalCase); if false, lowercases the first letter (camelCase). @default  `false`.
+ * @returns The camelCase version of the input string.
+ */
+declare function camelize<T extends string>(str?: T, { source }?: RegExp, { preserveInnerCase: pIC, upperFirst: uF }?: {
+    preserveInnerCase?: boolean | undefined;
+    upperFirst?: boolean | undefined;
+}): CamelCase<T>;
+/** Convert a camelCase or PascalCase string to a separator-based format (e.g. "helloWorld" to "hello-world").
+ * @param str The camelCase or PascalCase string to convert.
+ * @param separator The string to insert between words. @default  a hyphen ("-").
+ * @returns The uncamelized version of the input string with separators.
+ * @example
+ * uncamelize("helloWorld") // "hello-world"
+ * uncamelize("HelloWorld", "_") // "hello_world"
+ */
+declare function uncamelize<T extends string, S extends string = " ">(str: T, separator?: S): NoCamelCase<T, S>;
 /** Convert a rem value to pixels based on the font size of a given element.
  * @param rem The rem value to convert.
- * @param el The element to use for font size reference. Defaults to the root element.
+ * @param el The element to use for font size reference. @default  the root element.
  * @returns The equivalent pixel value.
  */
 declare function remToPx(rem: number, el?: HTMLElement): number;
 /** Convert a pixel value to rem based on the font size of a given element.
  * @param px The pixel value to convert.
- * @param el The element to use for font size reference. Defaults to the root element.
+ * @param el The element to use for font size reference. @default  the root element.
  * @returns The equivalent rem value.
  */
 declare function pxToRem(px: number, el?: HTMLElement): number;
@@ -73,7 +129,7 @@ declare function pxToRem(px: number, el?: HTMLElement): number;
 declare function parseCSSTime(time: any): number;
 /** Parse a CSS size value (i.e. "16px" or "1.5rem") into pixels.
  * @param size The CSS size string to parse.
- * @param el The element to use for rem reference if needed. Defaults to the root element.
+ * @param el The element to use for rem reference if needed. @default  the root element.
  * @returns The equivalent value in pixels.
  */
 declare function parseCSSSize(size: any, el?: HTMLElement): number;
@@ -89,11 +145,45 @@ declare function cleanURL(url: string): string;
  */
 declare function isSameURL(url1: unknown, url2: unknown): boolean;
 
+/** Throttles a function, ensuring it's only called once within a specified delay period.
+ * @param key Unique identifier for the throttled function, used to track its last execution time.
+ * @param fn Function to be throttled.
+ * @param delay Time in milliseconds to wait before allowing the function to be called again. @default  `30ms`.
+ * @param strict If `true`, exact timestamp difference between calls will be used else a `setTimeout()` will clear the throttle, allowing for more thread leniency. @default  `true`.
+ * @param signal Optional `AbortSignal` to automatically clear the throttle when aborted.
+ * @param win Optional `Window` object for scheduling the throttle timeout, useful for testing or if running in a non-browser environment.
+ */
+declare function throttle(key: string, fn: Function, delay?: number, strict?: ((fn: Function) => number) | boolean, signal?: AbortSignal, win?: Window): void;
+/** Debounces a function, ensuring it's only called after a quiet period of no further calls.
+ * @param key Unique identifier for the debounced function, used to track pending calls.
+ * @param fn Function to be debounced.
+ * @param delay Time in milliseconds to wait after the latest call before invoking the function. @default  `30ms`.
+ * @param strict If `true`, exact timestamp difference between calls will be used else pending timeout is reset each call for practical thread leniency. @default  `true`.
+ * @param signal Optional `AbortSignal` to automatically clear scheduled debounce execution when aborted.
+ * @param win Optional `Window` object for scheduling/clearing the debounce timeout, useful for testing or if running in a non-browser environment.
+ */
+declare function debounce(key: string, fn: Function, delay?: number, strict?: boolean, signal?: AbortSignal, win?: Window): void;
+/** Creates a loop using `requestAnimationFrame`, allowing for efficient execution of a function on every frame.
+ * @param key Unique identifier for the loop, used to manage its execution and allow for updates or cancellation.
+ * @param fn Function to be executed on every frame.
+ * @param signal Optional `AbortSignal` to automatically cancel the loop when aborted.
+ * @param win Optional `Window` object for scheduling the animation frame, useful for testing or if running in a non-browser environment.
+ *
+ * Game-like loops will be our lil secret... ~ "The Smoooth Criminal" :)
+ */
+declare function RAFLoop(key: string, fn: Function, signal?: AbortSignal, win?: Window & typeof globalThis): void;
+/** Cancels a loop created by `RAFLoop`.
+ * @param key Unique identifier for the loop to be cancelled.
+ * @returns True if the loop was successfully cancelled, false if no loop with the given key exists.
+ */
+declare const cancelRAFLoop: (key: string) => boolean;
 interface LimitedOptions {
     /** Storage key used to persist call counts. */
     key?: string;
-    /** Maximum number of allowed calls. */
+    /** Maximum number of allowed calls. @default 1 */
     maxTimes?: number;
+    /** Only allow calling once per session, regardless of maxTimes. @default true */
+    oncePerSession?: boolean;
 }
 interface LimitedHandle<T extends (...args: any[]) => any> {
     /** Call the wrapped function with the original arguments. */
@@ -137,7 +227,7 @@ declare const deepBreath: (w?: Window & typeof globalThis) => Promise<unknown>;
 declare function bindCleanupToSignal<Cb extends () => any>(cleanup: Cb, signal?: AbortSignal): Cb;
 
 /** Exhaustive Selector used for interactive, tabbable UI controls. */
-declare const INTERACTIVE_SELECTOR = ":is(button,[href],input:not([type='hidden']),select,textarea,details>summary,[contenteditable='true'],iframe,audio[controls],video[controls],[tabindex]):not([disabled],[tabindex='-1'],[data-focus-guard],[inert],[inert] *)";
+declare const INTERACTIVE_SELECTOR = ":is(button,[href],input:not([type='hidden']),select,textarea,details>summary,[contenteditable],iframe,audio[controls],video[controls],[tabindex]):not([disabled],[tabindex='-1'],[data-focus-guard],[inert],[inert] *)";
 /** Check whether an event target points to an interactive element. */
 declare const isInteractive: (target: EventTarget | null) => boolean;
 /** Resource type accepted by loadResource. */
@@ -169,16 +259,53 @@ declare const VIRTUAL_RESOURCE: symbol;
  * @param req Resource URL or virtual resource symbol.
  * @param type Resource type to load.
  * @param options Resource loading options.
- * @param w Window-like target used for DOM insertion.
+ * @param win Window-like target used for DOM insertion.
  * @returns Promise resolving to the created element or void.
  */
-declare function loadResource(req: string | symbol, type?: ResourceType, { module, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, attempts, retryKey }?: LoadResourceOptions, w?: Window & typeof globalThis): Promise<HTMLElement | void>;
+declare function loadResource(req: string | symbol, type?: ResourceType, { module, media, crossOrigin, integrity, referrerPolicy, nonce, fetchPriority, attempts, retryKey }?: LoadResourceOptions, win?: Window & typeof globalThis): Promise<HTMLElement | void>;
 
 /** Get the window object associated with a given element.
  * @param el The element to get the window for, defaults to the main window.
- * @returns The window object or undefined if none found.
+ * @returns The `Window` object or undefined if none found.
+ */
+declare function getWindow(el?: any): Window & typeof globalThis;
+/** Options for configuring a list renderer */
+type ListRendererOptions<T, El extends HTMLElement = HTMLElement> = {
+    /** The container element to render the list into */
+    container: HTMLElement;
+    /** Function to extract a unique key from each item.
+     * @param item The item to extract the key from
+     * @returns A unique string key for the item
+     */
+    getKey: (item: T) => string;
+    /** Function to create a DOM node for an item.
+     * @param item The item to create a node for
+     * @returns An HTMLElement representing the item, or null/undefined to skip rendering
+     */
+    createNode: (item: T) => El | null | undefined;
+    /** Optional function to update an existing node with new item data, called when an item is reused.
+     * @param node The existing DOM node for the item
+     * @param item The new item data to update the node with
+     */
+    updateNode?: (node: El, item: T) => void;
+    /** Optional function to clean up a DOM node when an item is removed, called before the node is removed from the DOM.
+     * @param node The DOM node to be removed
+     * @param key The unique key of the item associated with the node
+     */
+    destroyNode?: (node: El, key: string) => void;
+    /** Optional function called once during initialization for each existing child node in the container.
+     * Allows seeding the registry with pre-existing markup so nodes are reused instead of destroyed.
+     * @param node The pre-existing DOM node
+     * @param register A callback to register the node with its corresponding item key
+     */
+    initNode?: (node: El, register: (key: string) => void) => void;
+};
+/**
+ * Creates a list renderer function for efficiently updating a DOM list based on a new array of items using the L.I.S(Longest Increasing Subsequence) algorithm.
+ * @param param0 The options for configuring the list renderer
+ * @returns A function that synchronizes the DOM with the new array of items
  */
-declare function getWindow(el?: any): (Window & typeof globalThis) | undefined;
+declare function createListRenderer<T, El extends HTMLElement = HTMLElement>({ container, getKey, createNode, updateNode, destroyNode, initNode }: ListRendererOptions<T, El>): (array: T[], strict?: boolean) => void;
 
 /** Format a file size for display.
  * @param size Size in bytes.
@@ -188,4 +315,4 @@ declare function getWindow(el?: any): (Window & typeof globalThis) | undefined;
  */
 declare function formatSize(bytes: number, decimals?: number, base?: number): string;
 
-export { INTERACTIVE_SELECTOR, type LimitedHandle, type LimitedOptions, type LoadResourceOptions, type ResourceType, VIRTUAL_RESOURCE, bindCleanupToSignal, breath, cleanURL, deepBreath, formatSize, getWindow, inBoolArrOpt, isArr, isBool, isDef, isFunc, isInteractive, isIter, isNum, isPOJO, isSameURL, isStr, isSym, limited, loadResource, mockAsync, parseCSSSize, parseCSSTime, pxToRem, remToPx, uid };
+export { type CamelCase, INTERACTIVE_SELECTOR, type LimitedHandle, type LimitedOptions, type ListRendererOptions, type LoadResourceOptions, type NoCamelCase, RAFLoop, type ResourceType, type TitleCase, VIRTUAL_RESOURCE, bindCleanupToSignal, breath, camelize, cancelRAFLoop, capitalize, cleanURL, createListRenderer, debounce, deepBreath, formatSize, getWindow, inBoolArrOpt, isArr, isBool, isDef, isFunc, isInteractive, isIter, isNum, isPOJO, isSameURL, isStr, isSym, limited, loadResource, longestIncreasingSubsequence, mockAsync, parseCSSSize, parseCSSTime, pxToRem, remToPx, throttle, uid, uncamelize };