tempest-react-sdk 0.78.0 → 0.79.0

package/dist/utils/functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"functions.cjs","names":[],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":"AAYA,SAAgB,EACZ,EACA,EAC+C,CAC/C,IAAI,EAEE,GAAa,GAAG,IAAkB,CAChC,IAAU,IAAA,IAAW,aAAa,CAAK,EAC3C,EAAQ,eAAiB,CACrB,EAAQ,IAAA,GACR,EAAG,GAAG,CAAI,CACd,EAAG,CAAI,CACX,EASA,MAPA,GAAU,WAAqB,CACvB,IAAU,IAAA,KACV,aAAa,CAAK,EAClB,EAAQ,IAAA,GAEhB,EAEO,CACX,CAeA,SAAgB,EACZ,EACA,EAC+C,CAC/C,IAAI,EACA,EACA,EAAa,EAEX,EAAU,GAAkB,CAC9B,EAAa,KAAK,IAAI,EACtB,EAAG,GAAG,CAAI,CACd,EAEM,GAAa,GAAG,IAAkB,CAEpC,IAAM,EAAY,GADN,KAAK,IACS,EAAM,GAE5B,GAAa,GACT,IAAU,IAAA,KACV,aAAa,CAAK,EAClB,EAAQ,IAAA,IAEZ,EAAO,CAAI,IAEX,EAAW,EACP,IAAU,IAAA,KACV,EAAQ,eAAiB,CAErB,GADA,EAAQ,IAAA,GACJ,IAAa,IAAA,GAAW,CACxB,IAAM,EAAU,EAChB,EAAW,IAAA,GACX,EAAO,CAAO,CAClB,CACJ,EAAG,CAAS,GAGxB,EAWA,MATA,GAAU,WAAqB,CACvB,IAAU,IAAA,KACV,aAAa,CAAK,EAClB,EAAQ,IAAA,IAEZ,EAAW,IAAA,GACX,EAAa,CACjB,EAEO,CACX,CAUA,SAAgB,EAA6B,EAA0C,CACnF,IAAI,EAAS,GACT,EAEJ,OAAQ,GAAG,KACF,IACD,EAAS,GACT,EAAS,EAAG,GAAG,CAAI,GAEhB,EAEf,CAeA,SAAgB,EAAmC,EAA0C,CACzF,IAAI,EAAW,GACX,EACA,EAEE,EAAY,GAAqB,CACnC,GAAI,CAAC,GAAY,EAAK,SAAW,EAAS,OAAQ,MAAO,GACzD,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC7B,GAAI,CAAC,OAAO,GAAG,EAAK,GAAI,EAAS,EAAE,EAAG,MAAO,GAEjD,MAAO,EACX,EAEA,OAAQ,GAAG,IACH,EAAS,CAAI,EAAU,GAC3B,EAAW,EACX,EAAa,EAAG,GAAG,CAAI,EACvB,EAAW,GACJ,EAEf"}
+{"version":3,"file":"functions.cjs","names":["debounce","timer","debounced","args","fn","wait","throttle","lastArgs","lastInvoke","invoke","throttled","remaining","pending","once","called","result","memoizeOne","hasCache","lastResult","sameArgs","next","i"],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":"AAYA,SAAgBA,EACZ,EACA,EAC+C,CAC/C,IAAIC,EAEEC,GAAa,GAAGC,IAAkB,CAChCF,IAAU,IAAA,IAAW,aAAaA,CAAK,EAC3C,EAAQ,eAAiB,CACrB,EAAQ,IAAA,GACRG,EAAG,GAAGD,CAAI,CACd,EAAGE,CAAI,CACX,EASA,MAPA,GAAU,WAAqB,CACvBJ,IAAU,IAAA,KACV,aAAaA,CAAK,EAClB,EAAQ,IAAA,GAEhB,EAEOC,CACX,CAeA,SAAgBI,EACZ,EACA,EAC+C,CAC/C,IAAIL,EACAM,EACAC,EAAa,EAEXC,EAAU,GAAkB,CAC9B,EAAa,KAAK,IAAI,EACtBL,EAAG,GAAGD,CAAI,CACd,EAEMO,GAAa,GAAGP,IAAkB,CAEpC,IAAMQ,EAAYN,GADN,KAAK,IACS,EAAMG,GAE5BG,GAAa,GACTV,IAAU,IAAA,KACV,aAAaA,CAAK,EAClB,EAAQ,IAAA,IAEZQ,EAAON,CAAI,IAEX,EAAWA,EACPF,IAAU,IAAA,KACV,EAAQ,eAAiB,CAErB,GADA,EAAQ,IAAA,GACJM,IAAa,IAAA,GAAW,CACxB,IAAMK,EAAUL,EAChB,EAAW,IAAA,GACXE,EAAOG,CAAO,CAClB,CACJ,EAAGD,CAAS,GAGxB,EAWA,MATA,GAAU,WAAqB,CACvBV,IAAU,IAAA,KACV,aAAaA,CAAK,EAClB,EAAQ,IAAA,IAEZ,EAAW,IAAA,GACX,EAAa,CACjB,EAEOS,CACX,CAUA,SAAgBG,EAA6B,EAA0C,CACnF,IAAIC,EAAS,GACTC,EAEJ,OAAQ,GAAGZ,KACFW,IACD,EAAS,GACT,EAASV,EAAG,GAAGD,CAAI,GAEhBY,EAEf,CAeA,SAAgBC,EAAmC,EAA0C,CACzF,IAAIC,EAAW,GACXV,EACAW,EAEEC,EAAY,GAAqB,CACnC,GAAI,CAACF,GAAYG,EAAK,SAAWb,EAAS,OAAQ,MAAO,GACzD,IAAK,IAAIc,EAAI,EAAGA,EAAID,EAAK,OAAQ,IAC7B,GAAI,CAAC,OAAO,GAAGA,EAAKC,GAAId,EAASc,EAAE,EAAG,MAAO,GAEjD,MAAO,EACX,EAEA,OAAQ,GAAGlB,KACHgB,EAAShB,CAAI,IACjB,EAAWA,EACX,EAAaC,EAAG,GAAGD,CAAI,EACvB,EAAW,IACJe,EAEf,C"}

package/dist/utils/functions.js

@@ -35,7 +35,7 @@ function r(e) {
 		for (let t = 0; t < e.length; t++) if (!Object.is(e[t], n[t])) return !1;
 		return !0;
 	};
-	return (...a) => i(a) ? r : (n = a, r = e(...a), t = !0, r);
+	return (...a) => (i(a) || (n = a, r = e(...a), t = !0), r);
 }
 //#endregion
 export { e as debounce, r as memoizeOne, n as once, t as throttle };

package/dist/utils/functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"functions.js","names":[],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":";AAYA,SAAgB,EACZ,GACA,GAC+C;CAC/C,IAAI,GAEE,KAAa,GAAG,MAAkB;EAEpC,AADI,MAAU,KAAA,KAAW,aAAa,CAAK,GAC3C,IAAQ,iBAAiB;GAErB,AADA,IAAQ,KAAA,GACR,EAAG,GAAG,CAAI;EACd,GAAG,CAAI;CACX;CASA,OAPA,EAAU,eAAqB;EAC3B,AAAI,MAAU,KAAA,MACV,aAAa,CAAK,GAClB,IAAQ,KAAA;CAEhB,GAEO;AACX;AAeA,SAAgB,EACZ,GACA,GAC+C;CAC/C,IAAI,GACA,GACA,IAAa,GAEX,KAAU,MAAkB;EAE9B,AADA,IAAa,KAAK,IAAI,GACtB,EAAG,GAAG,CAAI;CACd,GAEM,KAAa,GAAG,MAAkB;EAEpC,IAAM,IAAY,KADN,KAAK,IACS,IAAM;EAEhC,AAAI,KAAa,KACT,MAAU,KAAA,MACV,aAAa,CAAK,GAClB,IAAQ,KAAA,IAEZ,EAAO,CAAI,MAEX,IAAW,GACP,MAAU,KAAA,MACV,IAAQ,iBAAiB;GAErB,IADA,IAAQ,KAAA,GACJ,MAAa,KAAA,GAAW;IACxB,IAAM,IAAU;IAEhB,AADA,IAAW,KAAA,GACX,EAAO,CAAO;GAClB;EACJ,GAAG,CAAS;CAGxB;CAWA,OATA,EAAU,eAAqB;EAM3B,AALI,MAAU,KAAA,MACV,aAAa,CAAK,GAClB,IAAQ,KAAA,IAEZ,IAAW,KAAA,GACX,IAAa;CACjB,GAEO;AACX;AAUA,SAAgB,EAA6B,GAA0C;CACnF,IAAI,IAAS,IACT;CAEJ,QAAQ,GAAG,OACF,MACD,IAAS,IACT,IAAS,EAAG,GAAG,CAAI,IAEhB;AAEf;AAeA,SAAgB,EAAmC,GAA0C;CACzF,IAAI,IAAW,IACX,GACA,GAEE,KAAY,MAAqB;EACnC,IAAI,CAAC,KAAY,EAAK,WAAW,EAAS,QAAQ,OAAO;EACzD,KAAK,IAAI,IAAI,GAAG,IAAI,EAAK,QAAQ,KAC7B,IAAI,CAAC,OAAO,GAAG,EAAK,IAAI,EAAS,EAAE,GAAG,OAAO;EAEjD,OAAO;CACX;CAEA,QAAQ,GAAG,MACH,EAAS,CAAI,IAAU,KAC3B,IAAW,GACX,IAAa,EAAG,GAAG,CAAI,GACvB,IAAW,IACJ;AAEf"}
+{"version":3,"file":"functions.js","names":["debounce","timer","debounced","args","fn","wait","throttle","lastArgs","lastInvoke","invoke","throttled","remaining","pending","once","called","result","memoizeOne","hasCache","lastResult","sameArgs","next","i"],"sources":["../../src/utils/functions.ts"],"sourcesContent":["/**\n * Create a trailing-edge debounced version of `fn`.\n *\n * The wrapped function delays invoking `fn` until `wait` milliseconds have\n * elapsed since the last time it was called. Only the latest arguments are\n * used. Call `.cancel()` to clear any pending invocation.\n *\n * @example\n * const save = debounce((q: string) => search(q), 300);\n * save(\"a\"); save(\"ab\"); save(\"abc\"); // only \"abc\" runs after 300ms\n * save.cancel();                       // nothing runs\n */\nexport function debounce<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    const debounced = (...args: A): void => {\n        if (timer !== undefined) clearTimeout(timer);\n        timer = setTimeout(() => {\n            timer = undefined;\n            fn(...args);\n        }, wait);\n    };\n\n    debounced.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n    };\n\n    return debounced;\n}\n\n/**\n * Create a throttled version of `fn` with leading and trailing edges.\n *\n * `fn` runs immediately on the first call (leading edge), then at most once\n * per `wait` milliseconds. If calls happen during the wait window, the last\n * one fires on the trailing edge. Call `.cancel()` to drop any pending\n * trailing call and reset the window.\n *\n * @example\n * const onScroll = throttle(() => render(), 200);\n * window.addEventListener(\"scroll\", onScroll);\n * onScroll.cancel();\n */\nexport function throttle<A extends unknown[]>(\n    fn: (...args: A) => void,\n    wait: number,\n): ((...args: A) => void) & { cancel: () => void } {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    let lastArgs: A | undefined;\n    let lastInvoke = 0;\n\n    const invoke = (args: A): void => {\n        lastInvoke = Date.now();\n        fn(...args);\n    };\n\n    const throttled = (...args: A): void => {\n        const now = Date.now();\n        const remaining = wait - (now - lastInvoke);\n\n        if (remaining <= 0) {\n            if (timer !== undefined) {\n                clearTimeout(timer);\n                timer = undefined;\n            }\n            invoke(args);\n        } else {\n            lastArgs = args;\n            if (timer === undefined) {\n                timer = setTimeout(() => {\n                    timer = undefined;\n                    if (lastArgs !== undefined) {\n                        const pending = lastArgs;\n                        lastArgs = undefined;\n                        invoke(pending);\n                    }\n                }, remaining);\n            }\n        }\n    };\n\n    throttled.cancel = (): void => {\n        if (timer !== undefined) {\n            clearTimeout(timer);\n            timer = undefined;\n        }\n        lastArgs = undefined;\n        lastInvoke = 0;\n    };\n\n    return throttled;\n}\n\n/**\n * Wrap `fn` so it runs at most once; subsequent calls return the cached result.\n *\n * @example\n * const init = once(() => expensiveSetup());\n * init(); // runs expensiveSetup()\n * init(); // returns the same cached result, no re-run\n */\nexport function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let called = false;\n    let result: R;\n\n    return (...args: A): R => {\n        if (!called) {\n            called = true;\n            result = fn(...args);\n        }\n        return result;\n    };\n}\n\n/**\n * Memoize only the most recent call of `fn`, keyed by shallow-equal arguments.\n *\n * If the next call has the same arguments (compared with `Object.is` per\n * position and equal length), the cached result is returned without re-running\n * `fn`. Any different argument list recomputes and replaces the cache.\n *\n * @example\n * const select = memoizeOne((a: number, b: number) => a + b);\n * select(1, 2); // computes 3\n * select(1, 2); // cached 3\n * select(2, 2); // recomputes 4\n */\nexport function memoizeOne<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R {\n    let hasCache = false;\n    let lastArgs: A;\n    let lastResult: R;\n\n    const sameArgs = (next: A): boolean => {\n        if (!hasCache || next.length !== lastArgs.length) return false;\n        for (let i = 0; i < next.length; i++) {\n            if (!Object.is(next[i], lastArgs[i])) return false;\n        }\n        return true;\n    };\n\n    return (...args: A): R => {\n        if (sameArgs(args)) return lastResult;\n        lastArgs = args;\n        lastResult = fn(...args);\n        hasCache = true;\n        return lastResult;\n    };\n}\n"],"mappings":";AAYA,SAAgBA,EACZ,GACA,GAC+C;CAC/C,IAAIC,GAEEC,KAAa,GAAGC,MAAkB;EAEpC,AADIF,MAAU,KAAA,KAAW,aAAaA,CAAK,GAC3C,IAAQ,iBAAiB;GAErB,AADA,IAAQ,KAAA,GACRG,EAAG,GAAGD,CAAI;EACd,GAAGE,CAAI;CACX;CASA,OAPA,EAAU,eAAqB;EAC3B,AAAIJ,MAAU,KAAA,MACV,aAAaA,CAAK,GAClB,IAAQ,KAAA;CAEhB,GAEOC;AACX;AAeA,SAAgBI,EACZ,GACA,GAC+C;CAC/C,IAAIL,GACAM,GACAC,IAAa,GAEXC,KAAU,MAAkB;EAE9B,AADA,IAAa,KAAK,IAAI,GACtBL,EAAG,GAAGD,CAAI;CACd,GAEMO,KAAa,GAAGP,MAAkB;EAEpC,IAAMQ,IAAYN,KADN,KAAK,IACS,IAAMG;EAEhC,AAAIG,KAAa,KACTV,MAAU,KAAA,MACV,aAAaA,CAAK,GAClB,IAAQ,KAAA,IAEZQ,EAAON,CAAI,MAEX,IAAWA,GACPF,MAAU,KAAA,MACV,IAAQ,iBAAiB;GAErB,IADA,IAAQ,KAAA,GACJM,MAAa,KAAA,GAAW;IACxB,IAAMK,IAAUL;IAEhB,AADA,IAAW,KAAA,GACXE,EAAOG,CAAO;GAClB;EACJ,GAAGD,CAAS;CAGxB;CAWA,OATA,EAAU,eAAqB;EAM3B,AALIV,MAAU,KAAA,MACV,aAAaA,CAAK,GAClB,IAAQ,KAAA,IAEZ,IAAW,KAAA,GACX,IAAa;CACjB,GAEOS;AACX;AAUA,SAAgBG,EAA6B,GAA0C;CACnF,IAAIC,IAAS,IACTC;CAEJ,QAAQ,GAAGZ,OACFW,MACD,IAAS,IACT,IAASV,EAAG,GAAGD,CAAI,IAEhBY;AAEf;AAeA,SAAgBC,EAAmC,GAA0C;CACzF,IAAIC,IAAW,IACXV,GACAW,GAEEC,KAAY,MAAqB;EACnC,IAAI,CAACF,KAAYG,EAAK,WAAWb,EAAS,QAAQ,OAAO;EACzD,KAAK,IAAIc,IAAI,GAAGA,IAAID,EAAK,QAAQ,KAC7B,IAAI,CAAC,OAAO,GAAGA,EAAKC,IAAId,EAASc,EAAE,GAAG,OAAO;EAEjD,OAAO;CACX;CAEA,QAAQ,GAAGlB,OACHgB,EAAShB,CAAI,MACjB,IAAWA,GACX,IAAaC,EAAG,GAAGD,CAAI,GACvB,IAAW,KACJe;AAEf"}

package/dist/utils/guards.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"guards.cjs","names":[],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":"AAUA,SAAgB,EAAa,EAAyC,CAClE,OAAO,GAAU,IACrB,CASA,SAAgB,EAAS,EAAiC,CACtD,OAAO,OAAO,GAAU,QAC5B,CAUA,SAAgB,EAAS,EAAiC,CACtD,OAAO,OAAO,GAAU,UAAY,CAAC,OAAO,MAAM,CAAK,CAC3D,CAcA,SAAgB,EAAc,EAAkD,CAC5E,GAAI,OAAO,GAAU,WAAY,EAAgB,MAAO,GACxD,IAAM,EAAQ,OAAO,eAAe,CAAK,EACzC,OAAO,IAAU,OAAO,WAAa,IAAU,IACnD,CAuBA,SAAgB,EAAY,EAAc,EAAyB,CAC/D,MAAU,MAAM,GAAW,qBAAqB,OAAO,CAAK,GAAG,CACnE"}
+{"version":3,"file":"guards.cjs","names":["isDefined","value","isString","isNumber","isPlainObject","proto","assertNever","message"],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":"AAUA,SAAgBA,EAAa,EAAyC,CAClE,OAAOC,GAAU,IACrB,CASA,SAAgBC,EAAS,EAAiC,CACtD,OAAO,OAAOD,GAAU,QAC5B,CAUA,SAAgBE,EAAS,EAAiC,CACtD,OAAO,OAAOF,GAAU,UAAY,CAAC,OAAO,MAAMA,CAAK,CAC3D,CAcA,SAAgBG,EAAc,EAAkD,CAC5E,GAAI,OAAOH,GAAU,WAAYA,EAAgB,MAAO,GACxD,IAAMI,EAAQ,OAAO,eAAeJ,CAAK,EACzC,OAAOI,IAAU,OAAO,WAAaA,IAAU,IACnD,CAuBA,SAAgBC,EAAY,EAAc,EAAyB,CAC/D,MAAU,MAAMC,GAAW,qBAAqB,OAAON,CAAK,GAAG,CACnE,C"}

package/dist/utils/guards.js.map

@@ -1 +1 @@
-{"version":3,"file":"guards.js","names":[],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":";AAUA,SAAgB,EAAa,GAAyC;CAClE,OAAO,KAAU;AACrB;AASA,SAAgB,EAAS,GAAiC;CACtD,OAAO,OAAO,KAAU;AAC5B;AAUA,SAAgB,EAAS,GAAiC;CACtD,OAAO,OAAO,KAAU,YAAY,CAAC,OAAO,MAAM,CAAK;AAC3D;AAcA,SAAgB,EAAc,GAAkD;CAC5E,IAAI,OAAO,KAAU,aAAY,GAAgB,OAAO;CACxD,IAAM,IAAQ,OAAO,eAAe,CAAK;CACzC,OAAO,MAAU,OAAO,aAAa,MAAU;AACnD;AAuBA,SAAgB,EAAY,GAAc,GAAyB;CAC/D,MAAU,MAAM,KAAW,qBAAqB,OAAO,CAAK,GAAG;AACnE"}
+{"version":3,"file":"guards.js","names":["isDefined","value","isString","isNumber","isPlainObject","proto","assertNever","message"],"sources":["../../src/utils/guards.ts"],"sourcesContent":["/**\n * Type guard asserting a value is neither `null` nor `undefined`.\n *\n * Useful for narrowing in `Array.prototype.filter` to drop nullish entries\n * while preserving the element type.\n *\n * @example\n * const xs: (number | null)[] = [1, null, 2];\n * const clean: number[] = xs.filter(isDefined); // [1, 2]\n */\nexport function isDefined<T>(value: T | null | undefined): value is T {\n    return value !== null && value !== undefined;\n}\n\n/**\n * Type guard asserting a value is a string primitive.\n *\n * @example\n * isString(\"hi\"); // true\n * isString(42);   // false\n */\nexport function isString(value: unknown): value is string {\n    return typeof value === \"string\";\n}\n\n/**\n * Type guard asserting a value is a number, excluding `NaN`.\n *\n * @example\n * isNumber(42);       // true\n * isNumber(NaN);      // false\n * isNumber(\"42\");     // false\n */\nexport function isNumber(value: unknown): value is number {\n    return typeof value === \"number\" && !Number.isNaN(value);\n}\n\n/**\n * Type guard asserting a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances —\n * only objects created from `{}` / `Object.create(null)` / object literals pass.\n *\n * @example\n * isPlainObject({ a: 1 });     // true\n * isPlainObject([]);           // false\n * isPlainObject(null);         // false\n * isPlainObject(new Date());   // false\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Assert that a code path is unreachable, throwing at runtime if reached.\n *\n * Use in the `default` branch of an exhaustive `switch` so TypeScript flags any\n * unhandled union member at compile time and the runtime fails loudly if an\n * unexpected value slips through.\n *\n * @param value - The value that should be of type `never`.\n * @param message - Optional custom error message.\n * @throws {Error} Always.\n *\n * @example\n * type Shape = \"circle\" | \"square\";\n * function area(shape: Shape): number {\n *   switch (shape) {\n *     case \"circle\": return 1;\n *     case \"square\": return 2;\n *     default: return assertNever(shape);\n *   }\n * }\n */\nexport function assertNever(value: never, message?: string): never {\n    throw new Error(message ?? `Unexpected value: ${String(value)}`);\n}\n"],"mappings":";AAUA,SAAgBA,EAAa,GAAyC;CAClE,OAAOC,KAAU;AACrB;AASA,SAAgBC,EAAS,GAAiC;CACtD,OAAO,OAAOD,KAAU;AAC5B;AAUA,SAAgBE,EAAS,GAAiC;CACtD,OAAO,OAAOF,KAAU,YAAY,CAAC,OAAO,MAAMA,CAAK;AAC3D;AAcA,SAAgBG,EAAc,GAAkD;CAC5E,IAAI,OAAOH,KAAU,aAAYA,GAAgB,OAAO;CACxD,IAAMI,IAAQ,OAAO,eAAeJ,CAAK;CACzC,OAAOI,MAAU,OAAO,aAAaA,MAAU;AACnD;AAuBA,SAAgBC,EAAY,GAAc,GAAyB;CAC/D,MAAU,MAAMC,KAAW,qBAAqB,OAAON,CAAK,GAAG;AACnE"}

package/dist/utils/ids.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ids.cjs","names":[],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":"AAWA,SAAgB,EAAS,EAAyB,CAC9C,IAAI,EAUJ,MARA,CAKI,EALA,OAAO,OAAW,KAAe,OAAO,OAAO,YAAe,WACzD,OAAO,WAAW,EAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAG,EACjC,IAGb,EAAS,GAAG,EAAO,GAAG,IAAO,CACxC"}
+{"version":3,"file":"ids.cjs","names":["randomId","id","prefix"],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":"AAWA,SAAgBA,EAAS,EAAyB,CAC9C,IAAIC,EAUJ,MARA,CAKIA,EALA,OAAO,OAAW,KAAe,OAAO,OAAO,YAAe,WACzD,OAAO,WAAW,EAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAG,EACjC,IAGbC,EAAS,GAAGA,EAAO,GAAGD,IAAOA,CACxC,C"}

package/dist/utils/ids.js.map

@@ -1 +1 @@
-{"version":3,"file":"ids.js","names":[],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":";AAWA,SAAgB,EAAS,GAAyB;CAC9C,IAAI;CAUJ,OARA,AAKI,IALA,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,aACzD,OAAO,WAAW,IAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EACjC,KAGb,IAAS,GAAG,EAAO,GAAG,MAAO;AACxC"}
+{"version":3,"file":"ids.js","names":["randomId","id","prefix"],"sources":["../../src/utils/ids.ts"],"sourcesContent":["/**\n * Generate a collision-resistant id suitable for client-side UI keys.\n *\n * Uses `crypto.randomUUID()` when available, falling back to a\n * timestamp + `Math.random()` combination otherwise. When `prefix` is given,\n * the result is formatted as `${prefix}-${id}`.\n *\n * @example\n * randomId();          // \"9f1c2b3a-...\" (uuid) or \"lq3f8k-4a9z1\" (fallback)\n * randomId(\"user\");    // \"user-9f1c2b3a-...\"\n */\nexport function randomId(prefix?: string): string {\n    let id: string;\n\n    if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n        id = crypto.randomUUID();\n    } else {\n        const time = Date.now().toString(36);\n        const rand = Math.random().toString(36).slice(2, 10);\n        id = `${time}-${rand}`;\n    }\n\n    return prefix ? `${prefix}-${id}` : id;\n}\n"],"mappings":";AAWA,SAAgBA,EAAS,GAAyB;CAC9C,IAAIC;CAUJ,OARA,AAKIA,IALA,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,aACzD,OAAO,WAAW,IAIlB,GAFQ,KAAK,IAAI,CAAC,CAAC,SAAS,EAEzB,EAAK,GADA,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EACjC,KAGbC,IAAS,GAAGA,EAAO,GAAGD,MAAOA;AACxC"}

package/dist/utils/intl-cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"intl-cache.cjs","names":[],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":"AAmBA,IAEM,EAAgB,IAAI,IACpB,EAAkB,IAAI,IAS5B,SAAS,EAAO,EAA4B,EAAqC,CAC7E,MAAO,GAAG,GAAU,GAAG,GAAG,IAAY,IAAA,GAAY,GAAK,KAAK,UAAU,CAAO,GACjF,CASA,SAAgB,EACZ,EACA,EACiB,CACjB,IAAM,EAAM,EAAO,EAAQ,CAAO,EAC5B,EAAM,EAAc,IAAI,CAAG,EACjC,GAAI,EAAK,OAAO,EACZ,EAAc,MAAQ,IAAa,EAAc,MAAM,EAC3D,IAAM,EAAY,IAAI,KAAK,aAAa,EAAQ,CAAO,EAEvD,OADA,EAAc,IAAI,EAAK,CAAS,EACzB,CACX,CASA,SAAgB,EACZ,EACA,EACmB,CACnB,IAAM,EAAM,EAAO,EAAQ,CAAO,EAC5B,EAAM,EAAgB,IAAI,CAAG,EACnC,GAAI,EAAK,OAAO,EACZ,EAAgB,MAAQ,IAAa,EAAgB,MAAM,EAC/D,IAAM,EAAY,IAAI,KAAK,eAAe,EAAQ,CAAO,EAEzD,OADA,EAAgB,IAAI,EAAK,CAAS,EAC3B,CACX"}
+{"version":3,"file":"intl-cache.cjs","names":["numberFormats","dateTimeFormats","keyFor","locale","options","numberFormat","key","hit","formatter","dateTimeFormat"],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":"AAmBA,IAEMA,EAAgB,IAAI,IACpBC,EAAkB,IAAI,IAS5B,SAASC,EAAO,EAA4B,EAAqC,CAC7E,MAAO,GAAGC,GAAU,GAAG,GAAGC,IAAY,IAAA,GAAY,GAAK,KAAK,UAAUA,CAAO,GACjF,CASA,SAAgBC,EACZ,EACA,EACiB,CACjB,IAAMC,EAAMJ,EAAOC,EAAQC,CAAO,EAC5BG,EAAMP,EAAc,IAAIM,CAAG,EACjC,GAAIC,EAAK,OAAOA,EACZP,EAAc,MAAQ,IAAaA,EAAc,MAAM,EAC3D,IAAMQ,EAAY,IAAI,KAAK,aAAaL,EAAQC,CAAO,EAEvD,OADAJ,EAAc,IAAIM,EAAKE,CAAS,EACzBA,CACX,CASA,SAAgBC,EACZ,EACA,EACmB,CACnB,IAAMH,EAAMJ,EAAOC,EAAQC,CAAO,EAC5BG,EAAMN,EAAgB,IAAIK,CAAG,EACnC,GAAIC,EAAK,OAAOA,EACZN,EAAgB,MAAQ,IAAaA,EAAgB,MAAM,EAC/D,IAAMO,EAAY,IAAI,KAAK,eAAeL,EAAQC,CAAO,EAEzD,OADAH,EAAgB,IAAIK,EAAKE,CAAS,EAC3BA,CACX,C"}

package/dist/utils/intl-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"intl-cache.js","names":[],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":";AAmBA,IAEM,oBAAgB,IAAI,IAA+B,GACnD,oBAAkB,IAAI,IAAiC;AAS7D,SAAS,EAAO,GAA4B,GAAqC;CAC7E,OAAO,GAAG,KAAU,GAAG,GAAG,MAAY,KAAA,IAAY,KAAK,KAAK,UAAU,CAAO;AACjF;AASA,SAAgB,EACZ,GACA,GACiB;CACjB,IAAM,IAAM,EAAO,GAAQ,CAAO,GAC5B,IAAM,EAAc,IAAI,CAAG;CACjC,IAAI,GAAK,OAAO;CAChB,AAAI,EAAc,QAAQ,MAAa,EAAc,MAAM;CAC3D,IAAM,IAAY,IAAI,KAAK,aAAa,GAAQ,CAAO;CAEvD,OADA,EAAc,IAAI,GAAK,CAAS,GACzB;AACX;AASA,SAAgB,EACZ,GACA,GACmB;CACnB,IAAM,IAAM,EAAO,GAAQ,CAAO,GAC5B,IAAM,EAAgB,IAAI,CAAG;CACnC,IAAI,GAAK,OAAO;CAChB,AAAI,EAAgB,QAAQ,MAAa,EAAgB,MAAM;CAC/D,IAAM,IAAY,IAAI,KAAK,eAAe,GAAQ,CAAO;CAEzD,OADA,EAAgB,IAAI,GAAK,CAAS,GAC3B;AACX"}
+{"version":3,"file":"intl-cache.js","names":["numberFormats","dateTimeFormats","keyFor","locale","options","numberFormat","key","hit","formatter","dateTimeFormat"],"sources":["../../src/utils/intl-cache.ts"],"sourcesContent":["/**\n * Cached `Intl` formatter factories.\n *\n * Constructing an `Intl.NumberFormat` or `Intl.DateTimeFormat` resolves locale\n * data, which is the expensive half; formatting with one afterwards is cheap.\n * Building a fresh formatter per call is therefore the difference between a\n * table of money cells costing microseconds and costing a frame: measured at\n * 15.56 µs per construct-and-format against 0.29 µs when the formatter is\n * reused, so a 500 × 3 grid goes from 23.1 ms to 0.4 ms.\n *\n * The cache is keyed by locale plus the serialised options, so two call sites\n * asking for the same shape share one formatter. It is capped and cleared\n * wholesale when it overflows: a caller that varies its options per call (a\n * fraction-digit count driven by data, say) would otherwise grow the map without\n * bound, and dropping everything is both correct and cheaper than tracking\n * recency for a map this small.\n */\n\n/** Largest number of distinct formatter shapes kept before the cache resets. */\nconst MAX_ENTRIES = 64;\n\nconst numberFormats = new Map<string, Intl.NumberFormat>();\nconst dateTimeFormats = new Map<string, Intl.DateTimeFormat>();\n\n/**\n * Build the cache key for a locale and options pair.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - The formatter options, or `undefined`.\n * @returns A string that is equal exactly when both inputs are equivalent.\n */\nfunction keyFor(locale: string | undefined, options: object | undefined): string {\n    return `${locale ?? \"\"}|${options === undefined ? \"\" : JSON.stringify(options)}`;\n}\n\n/**\n * Get an `Intl.NumberFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.NumberFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function numberFormat(\n    locale?: string,\n    options?: Intl.NumberFormatOptions,\n): Intl.NumberFormat {\n    const key = keyFor(locale, options);\n    const hit = numberFormats.get(key);\n    if (hit) return hit;\n    if (numberFormats.size >= MAX_ENTRIES) numberFormats.clear();\n    const formatter = new Intl.NumberFormat(locale, options);\n    numberFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Get an `Intl.DateTimeFormat`, reusing one already built for the same shape.\n *\n * @param locale - The BCP 47 locale, or `undefined` for the runtime default.\n * @param options - Standard `Intl.DateTimeFormat` options.\n * @returns A formatter that must not be mutated by the caller.\n */\nexport function dateTimeFormat(\n    locale?: string,\n    options?: Intl.DateTimeFormatOptions,\n): Intl.DateTimeFormat {\n    const key = keyFor(locale, options);\n    const hit = dateTimeFormats.get(key);\n    if (hit) return hit;\n    if (dateTimeFormats.size >= MAX_ENTRIES) dateTimeFormats.clear();\n    const formatter = new Intl.DateTimeFormat(locale, options);\n    dateTimeFormats.set(key, formatter);\n    return formatter;\n}\n\n/**\n * Drop every cached formatter.\n *\n * Exists for tests that assert on cache behaviour; production code has no\n * reason to call it, because a formatter never goes stale.\n *\n * @returns Nothing.\n */\nexport function clearIntlCache(): void {\n    numberFormats.clear();\n    dateTimeFormats.clear();\n}\n"],"mappings":";AAmBA,IAEMA,oBAAgB,IAAI,IAA+B,GACnDC,oBAAkB,IAAI,IAAiC;AAS7D,SAASC,EAAO,GAA4B,GAAqC;CAC7E,OAAO,GAAGC,KAAU,GAAG,GAAGC,MAAY,KAAA,IAAY,KAAK,KAAK,UAAUA,CAAO;AACjF;AASA,SAAgBC,EACZ,GACA,GACiB;CACjB,IAAMC,IAAMJ,EAAOC,GAAQC,CAAO,GAC5BG,IAAMP,EAAc,IAAIM,CAAG;CACjC,IAAIC,GAAK,OAAOA;CAChB,AAAIP,EAAc,QAAQ,MAAaA,EAAc,MAAM;CAC3D,IAAMQ,IAAY,IAAI,KAAK,aAAaL,GAAQC,CAAO;CAEvD,OADAJ,EAAc,IAAIM,GAAKE,CAAS,GACzBA;AACX;AASA,SAAgBC,EACZ,GACA,GACmB;CACnB,IAAMH,IAAMJ,EAAOC,GAAQC,CAAO,GAC5BG,IAAMN,EAAgB,IAAIK,CAAG;CACnC,IAAIC,GAAK,OAAOA;CAChB,AAAIN,EAAgB,QAAQ,MAAaA,EAAgB,MAAM;CAC/D,IAAMO,IAAY,IAAI,KAAK,eAAeL,GAAQC,CAAO;CAEzD,OADAH,EAAgB,IAAIK,GAAKE,CAAS,GAC3BA;AACX"}

package/dist/utils/json-frame.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"json-frame.cjs","names":[],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":"iEAqCA,IAAM,EAAS,IAAI,IAWnB,SAAS,EAAS,EAAyB,CAClC,EAAA,WAAW,GAAK,GAAO,IAAI,CAAS,IACzC,EAAO,IAAI,CAAS,EACpB,QAAQ,KACJ,uBAAuB,EAAU,oNAGrC,EACJ,CAcA,SAAS,EAAmB,EAAmB,EAA6B,CACxE,IAAM,EAAM,GAAG,EAAU,SACzB,GAAI,CAAC,EAAA,WAAW,GAAK,EAAO,IAAI,CAAG,EAAG,OACtC,EAAO,IAAI,CAAG,EACd,IAAM,EAAU,EAAO,IAAK,GAAU,GAAG,EAAM,KAAK,IAAI,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI,EAClF,QAAQ,KACJ,uBAAuB,EAAU,sDACzB,EAAQ,gFAEpB,CACJ,CA8BA,SAAgB,EACZ,EACA,EACA,EACe,CACf,GAAM,CAAE,SAAQ,eAAc,SAAQ,qBAAsB,EAQ5D,SAAS,EAAK,EAAiC,CAC3C,GAAI,CAAC,EAAQ,MAAO,CAAE,UAAW,GAAM,KAAM,CAAW,EACxD,IAAM,EAAS,EAAA,mBAAmB,EAAQ,CAAK,EAI/C,OAHI,EAAO,GAAW,CAAE,UAAW,GAAM,KAAM,EAAO,IAAK,GACvD,EAAmB,EAAkB,EAAO,OAAQ,CAAG,EACtD,EAAmB,EAAW,EAAO,MAAM,EACzC,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,EACpD,CAEA,GAAI,EAAQ,OAAO,EAAK,EAAO,CAAG,CAAC,EACnC,IAAI,EACJ,GAAI,CACA,EAAS,KAAK,MAAM,CAAG,CAC3B,OAAS,EAAO,CAOZ,OANI,GACA,EAAa,EAAO,CAAG,EAChB,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,GAEhD,EAAe,EAAK,CAAG,GAC3B,EAAS,CAAS,EACX,CAAE,UAAW,GAAM,KAAM,CAAoB,EACxD,CACA,OAAO,EAAK,CAAM,CACtB"}
+{"version":3,"file":"json-frame.cjs","names":["isDevBuild","validateWithSchema","require_dev_mode","require_schema_like","warned","warnOnce","transport","warnValidationOnce","key","summary","issues","issue","decodeFrame","options","gate","schema","value","result","onValidationError","raw","parser","parsed","error","onParseError"],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":"A,iEAqCA,IAAMI,EAAS,IAAI,IAWnB,SAASC,EAAS,EAAyB,CAClCL,EAAAA,WAAW,GAAK,GAAO,IAAIM,CAAS,IACzCF,EAAO,IAAIE,CAAS,EACpB,QAAQ,KACJ,uBAAuBA,EAAU,oNAGrC,EACJ,CAcA,SAASC,EAAmB,EAAmB,EAA6B,CACxE,IAAMC,EAAM,GAAGF,EAAU,SACzB,GAAI,CAACN,EAAAA,WAAW,GAAKI,EAAO,IAAII,CAAG,EAAG,OACtCJ,EAAO,IAAII,CAAG,EACd,IAAMC,EAAUC,EAAO,IAAK,GAAU,GAAGC,EAAM,KAAK,IAAIA,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI,EAClF,QAAQ,KACJ,uBAAuBL,EAAU,sDACzBG,EAAQ,gFAEpB,CACJ,CA8BA,SAAgBG,EACZ,EACA,EACA,EACe,CACf,GAAM,CAAE,SAAQ,eAAc,SAAQ,qBAAsBC,EAQ5D,SAASC,EAAK,EAAiC,CAC3C,GAAI,CAACC,EAAQ,MAAO,CAAE,UAAW,GAAM,KAAMC,CAAW,EACxD,IAAMC,EAAShB,EAAAA,mBAAmBc,EAAQC,CAAK,EAI/C,OAHIC,EAAO,GAAW,CAAE,UAAW,GAAM,KAAMA,EAAO,IAAK,GACvDC,EAAmBA,EAAkBD,EAAO,OAAQE,CAAG,EACtDZ,EAAmBD,EAAWW,EAAO,MAAM,EACzC,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,EACpD,CAEA,GAAIG,EAAQ,OAAON,EAAKM,EAAOD,CAAG,CAAC,EACnC,IAAIE,EACJ,GAAI,CACA,EAAS,KAAK,MAAMF,CAAG,CAC3B,OAASG,EAAO,CAOZ,OANIC,GACAA,EAAaD,EAAOH,CAAG,EAChB,CAAE,UAAW,GAAO,KAAM,IAAA,EAAe,GAEhDJ,EAAeD,EAAKK,CAAG,GAC3Bd,EAASC,CAAS,EACX,CAAE,UAAW,GAAM,KAAMa,CAAoB,EACxD,CACA,OAAOL,EAAKO,CAAM,CACtB,C"}

package/dist/utils/json-frame.js.map

@@ -1 +1 @@
-{"version":3,"file":"json-frame.js","names":[],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":";;;AAqCA,IAAM,oBAAS,IAAI,IAAY;AAW/B,SAAS,EAAS,GAAyB;CACnC,AAAC,EAAW,KAAK,GAAO,IAAI,CAAS,MACzC,EAAO,IAAI,CAAS,GACpB,QAAQ,KACJ,uBAAuB,EAAU,oNAGrC;AACJ;AAcA,SAAS,EAAmB,GAAmB,GAA6B;CACxE,IAAM,IAAM,GAAG,EAAU;CACzB,IAAI,CAAC,EAAW,KAAK,EAAO,IAAI,CAAG,GAAG;CACtC,EAAO,IAAI,CAAG;CACd,IAAM,IAAU,EAAO,KAAK,MAAU,GAAG,EAAM,KAAK,IAAI,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI;CAClF,QAAQ,KACJ,uBAAuB,EAAU,sDACzB,EAAQ,gFAEpB;AACJ;AA8BA,SAAgB,EACZ,GACA,GACA,GACe;CACf,IAAM,EAAE,WAAQ,iBAAc,WAAQ,yBAAsB;CAQ5D,SAAS,EAAK,GAAiC;EAC3C,IAAI,CAAC,GAAQ,OAAO;GAAE,WAAW;GAAM,MAAM;EAAW;EACxD,IAAM,IAAS,EAAmB,GAAQ,CAAK;EAI/C,OAHI,EAAO,KAAW;GAAE,WAAW;GAAM,MAAM,EAAO;EAAK,KACvD,IAAmB,EAAkB,EAAO,QAAQ,CAAG,IACtD,EAAmB,GAAW,EAAO,MAAM,GACzC;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe;CACpD;CAEA,IAAI,GAAQ,OAAO,EAAK,EAAO,CAAG,CAAC;CACnC,IAAI;CACJ,IAAI;EACA,IAAS,KAAK,MAAM,CAAG;CAC3B,SAAS,GAAO;EAOZ,OANI,KACA,EAAa,GAAO,CAAG,GAChB;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe,KAEhD,IAAe,EAAK,CAAG,KAC3B,EAAS,CAAS,GACX;GAAE,WAAW;GAAM,MAAM;EAAoB;CACxD;CACA,OAAO,EAAK,CAAM;AACtB"}
+{"version":3,"file":"json-frame.js","names":["warned","warnOnce","isDevBuild","transport","warnValidationOnce","key","summary","issues","issue","decodeFrame","options","gate","schema","value","result","validateWithSchema","onValidationError","raw","parser","parsed","error","onParseError"],"sources":["../../src/utils/json-frame.ts"],"sourcesContent":["import { isDevBuild } from \"./dev-mode\";\nimport { validateWithSchema, type SchemaIssue, type SchemaLike } from \"./schema-like\";\n\n/**\n * The one decoder behind `createWebSocket`, `useWebSocket` and\n * `createEventStream`.\n *\n * Internal, and imported by path rather than through the `utils` barrel: it\n * exists so the three transports share one answer to \"the frame is not JSON\",\n * not so consumers can call it.\n *\n * That question used to have three identical copies of the same wrong answer —\n * `return raw as unknown as T`, which hands the consumer a `string` announced as\n * `T`. The failure never surfaced at the parse; it surfaced later, on the first\n * `message.id`, with nothing left to say the frame had not been JSON.\n */\n\n/** Outcome of decoding one frame. */\nexport interface DecodedFrame<T> {\n    /** Whether the message should reach `onMessage`. */\n    delivered: boolean;\n    /** The decoded payload. Only meaningful when `delivered` is `true`. */\n    data: T;\n}\n\n/** How one frame should be turned into `T`, and who hears about failures. */\nexport interface DecodeFrameOptions<T> {\n    /** Caller-supplied decoder, which owns the frame completely. */\n    parser?: (raw: string) => T;\n    /** Caller-supplied handler for a frame that is not valid JSON. */\n    onParseError?: (error: unknown, raw: string) => void;\n    /** Caller-supplied schema the decoded payload must satisfy. */\n    schema?: SchemaLike<T>;\n    /** Caller-supplied handler for a payload the schema refused. */\n    onValidationError?: (issues: SchemaIssue[], raw: string) => void;\n}\n\nconst warned = new Set<string>();\n\n/**\n * Warn once per transport that a frame arrived which was not JSON.\n *\n * Once, because a stream sending text frames sends many, and a console line per\n * frame buries the one that mattered. Development builds only.\n *\n * @param transport - Label used in the message, e.g. `\"createWebSocket\"`.\n * @returns Nothing.\n */\nfunction warnOnce(transport: string): void {\n    if (!isDevBuild() || warned.has(transport)) return;\n    warned.add(transport);\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame was not valid JSON, so the raw string is ` +\n            `being delivered as if it were your message type. Pass \\`parser\\` to decode it, or ` +\n            `\\`onParseError\\` to drop it and handle the failure. This warning appears once.`,\n    );\n}\n\n/**\n * Warn once per transport that a frame was dropped by the schema.\n *\n * A dropped frame with no `onValidationError` is otherwise completely silent —\n * the stream looks healthy and the payload simply never arrives, which is the\n * hardest shape of failure to notice. Development builds only, once, for the\n * same reason as {@link warnOnce}.\n *\n * @param transport - Label used in the message, e.g. `\"createEventStream\"`.\n * @param issues - The issues the schema reported, summarized into the message.\n * @returns Nothing.\n */\nfunction warnValidationOnce(transport: string, issues: SchemaIssue[]): void {\n    const key = `${transport}:schema`;\n    if (!isDevBuild() || warned.has(key)) return;\n    warned.add(key);\n    const summary = issues.map((issue) => `${issue.path}: ${issue.message}`).join(\"; \");\n    console.warn(\n        `[tempest-react-sdk] ${transport}: a frame did not match \\`schema\\` and was dropped ` +\n            `(${summary}). Pass \\`onValidationError\\` to handle it yourself. This warning ` +\n            `appears once.`,\n    );\n}\n\n/**\n * Decode one frame, reporting whether it should be delivered.\n *\n * A caller-supplied `parser` owns the frame completely: its result is delivered\n * as it is, or validated when a `schema` was also supplied — decoding text,\n * binary-as-base64 or a protocol of its own is the point of that option.\n *\n * Without one, the frame is parsed as JSON. When that throws:\n *\n * - with `onParseError`, the callback fires and the frame is **not** delivered,\n *   because a consumer that asked to hear about failures did not ask to also\n *   receive the broken frame;\n * - with `schema` and no `onParseError`, the raw string goes to the schema,\n *   which refuses it — a caller who asked for validation never receives an\n *   unvalidated payload, and a frame the server sent empty is exactly this case;\n * - with neither, the raw string is delivered as `T` — the behaviour every\n *   version before this one had, kept so nothing breaks — and development builds\n *   warn once that it happened.\n *\n * With a `schema`, a payload the schema refuses is not delivered, and\n * `onValidationError` hears the issues. The value delivered is the schema's\n * **output**, so a schema that coerces or defaults is honoured.\n *\n * @param raw - The frame body as text.\n * @param transport - Label used in the development warnings.\n * @param options - Caller-supplied decoder, schema and failure handlers.\n * @returns Whether to deliver, and the payload.\n */\nexport function decodeFrame<T>(\n    raw: string,\n    transport: string,\n    options: DecodeFrameOptions<T>,\n): DecodedFrame<T> {\n    const { parser, onParseError, schema, onValidationError } = options;\n\n    /**\n     * Put one decoded payload through the schema, when there is one.\n     *\n     * @param value - The payload as parsing produced it.\n     * @returns Whether to deliver, and the payload the consumer should see.\n     */\n    function gate(value: unknown): DecodedFrame<T> {\n        if (!schema) return { delivered: true, data: value as T };\n        const result = validateWithSchema(schema, value);\n        if (result.ok) return { delivered: true, data: result.data };\n        if (onValidationError) onValidationError(result.issues, raw);\n        else warnValidationOnce(transport, result.issues);\n        return { delivered: false, data: undefined as T };\n    }\n\n    if (parser) return gate(parser(raw));\n    let parsed: unknown;\n    try {\n        parsed = JSON.parse(raw);\n    } catch (error) {\n        if (onParseError) {\n            onParseError(error, raw);\n            return { delivered: false, data: undefined as T };\n        }\n        if (schema) return gate(raw);\n        warnOnce(transport);\n        return { delivered: true, data: raw as unknown as T };\n    }\n    return gate(parsed);\n}\n\n/**\n * Forget which transports have already warned.\n *\n * Exists for tests, which would otherwise see the first case swallow the\n * warning for every case after it.\n *\n * @returns Nothing.\n */\nexport function resetFrameWarnings(): void {\n    warned.clear();\n}\n"],"mappings":";;;AAqCA,IAAMA,oBAAS,IAAI,IAAY;AAW/B,SAASC,EAAS,GAAyB;CACvC,AAAKC,EAAW,KAAK,GAAO,IAAIC,CAAS,MACzCH,EAAO,IAAIG,CAAS,GACpB,QAAQ,KACJ,uBAAuBA,EAAU,oNAGrC;AACJ;AAcA,SAASC,EAAmB,GAAmB,GAA6B;CACxE,IAAMC,IAAM,GAAGF,EAAU;CACzB,IAAI,CAACD,EAAW,KAAKF,EAAO,IAAIK,CAAG,GAAG;CACtC,EAAO,IAAIA,CAAG;CACd,IAAMC,IAAUC,EAAO,KAAK,MAAU,GAAGC,EAAM,KAAK,IAAIA,EAAM,SAAS,CAAC,CAAC,KAAK,IAAI;CAClF,QAAQ,KACJ,uBAAuBL,EAAU,sDACzBG,EAAQ,gFAEpB;AACJ;AA8BA,SAAgBG,EACZ,GACA,GACA,GACe;CACf,IAAM,EAAE,WAAQ,iBAAc,WAAQ,yBAAsBC;CAQ5D,SAASC,EAAK,GAAiC;EAC3C,IAAI,CAACC,GAAQ,OAAO;GAAE,WAAW;GAAM,MAAMC;EAAW;EACxD,IAAMC,IAASC,EAAmBH,GAAQC,CAAK;EAI/C,OAHIC,EAAO,KAAW;GAAE,WAAW;GAAM,MAAMA,EAAO;EAAK,KACvDE,IAAmBA,EAAkBF,EAAO,QAAQG,CAAG,IACtDb,EAAmBD,GAAWW,EAAO,MAAM,GACzC;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe;CACpD;CAEA,IAAII,GAAQ,OAAOP,EAAKO,EAAOD,CAAG,CAAC;CACnC,IAAIE;CACJ,IAAI;EACA,IAAS,KAAK,MAAMF,CAAG;CAC3B,SAASG,GAAO;EAOZ,OANIC,KACAA,EAAaD,GAAOH,CAAG,GAChB;GAAE,WAAW;GAAO,MAAM,KAAA;EAAe,KAEhDL,IAAeD,EAAKM,CAAG,KAC3BhB,EAASE,CAAS,GACX;GAAE,WAAW;GAAM,MAAMc;EAAoB;CACxD;CACA,OAAON,EAAKQ,CAAM;AACtB"}

package/dist/utils/numbers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"numbers.cjs","names":[],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":"8DAUA,SAAgB,EAAM,EAAe,EAAa,EAAqB,CACnE,GAAI,OAAO,MAAM,CAAK,EAAG,OAAO,EAChC,GAAI,EAAM,EAAK,CACX,IAAM,EAAO,EACb,EAAM,EACN,EAAM,CACV,CAGA,OAFI,EAAQ,EAAY,EACpB,EAAQ,EAAY,EACjB,CACX,CAqBA,SAAgB,EACZ,EACA,EAAmB,EACnB,EACM,CACN,GAAI,EAAA,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EAAG,OAAO,EAAA,aAAa,CAAO,EAC3E,GAAI,IAAU,EAAG,MAAO,MAExB,IAAM,EAAQ,CAAC,IAAK,KAAM,KAAM,KAAM,IAAI,EACpC,EAAO,KACP,EAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,CAAK,CAAC,EAAI,KAAK,IAAI,CAAI,CAAC,EACrD,EAAM,OAAS,CACnB,EACM,EAAQ,EAAQ,GAAQ,EACxB,EAAS,IAAa,EAAI,EAAI,KAAK,IAAI,EAAG,CAAQ,EAGxD,MAAO,GAFW,WAAW,EAAM,QAAQ,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAG,EAAM,IACjC,CA2BA,SAAgB,EAAU,EAAc,EAAuB,CAE3D,MADI,CAAC,OAAO,SAAS,CAAI,GAAK,CAAC,OAAO,SAAS,CAAK,GAAK,IAAU,EAAU,EACrE,EAAO,EAAS,GAC5B,CAkBA,SAAgB,EACZ,EACA,EAAiB,QACjB,EACM,CAEN,OADI,EAAA,SAAS,CAAK,GAAK,CAAC,OAAO,SAAS,CAAK,EAAU,EAAA,aAAa,CAAO,EACpE,EAAA,aAAa,EAAQ,CAAE,SAAU,UAAW,sBAAuB,CAAE,CAAC,CAAC,CAAC,OAAO,CAAK,CAC/F"}
+{"version":3,"file":"numbers.cjs","names":["isAbsent","fallbackText","numberFormat","require_absent","require_intl_cache","clamp","value","min","max","swap","formatBytes","bytes","options","units","base","exponent","digits","decimals","percentOf","part","total","formatCompactNumber","locale"],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":"A,8DAUA,SAAgBK,EAAM,EAAe,EAAa,EAAqB,CACnE,GAAI,OAAO,MAAMC,CAAK,EAAG,OAAOA,EAChC,GAAIC,EAAMC,EAAK,CACX,IAAMC,EAAOF,EACb,EAAMC,EACN,EAAMC,CACV,CAGA,OAFIH,EAAQC,EAAYA,EACpBD,EAAQE,EAAYA,EACjBF,CACX,CAqBA,SAAgBI,EACZ,EACA,EAAmB,EACnB,EACM,CACN,GAAIV,EAAAA,SAASW,CAAK,GAAK,CAAC,OAAO,SAASA,CAAK,EAAG,OAAOV,EAAAA,aAAaW,CAAO,EAC3E,GAAID,IAAU,EAAG,MAAO,MAExB,IAAME,EAAQ,CAAC,IAAK,KAAM,KAAM,KAAM,IAAI,EACpCC,EAAO,KACPC,EAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAIJ,CAAK,CAAC,EAAI,KAAK,IAAIG,CAAI,CAAC,EACrDD,EAAM,OAAS,CACnB,EACMP,EAAQK,EAAQG,GAAQC,EACxBC,EAASD,IAAa,EAAI,EAAI,KAAK,IAAI,EAAGE,CAAQ,EAGxD,MAAO,GAFW,WAAWX,EAAM,QAAQU,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAGH,EAAME,IACjC,CA2BA,SAAgBG,EAAU,EAAc,EAAuB,CAE3D,MADI,CAAC,OAAO,SAASC,CAAI,GAAK,CAAC,OAAO,SAASC,CAAK,GAAKA,IAAU,EAAU,EACrED,EAAOC,EAAS,GAC5B,CAkBA,SAAgBC,EACZ,EACA,EAAiB,QACjB,EACM,CAEN,OADIrB,EAAAA,SAASM,CAAK,GAAK,CAAC,OAAO,SAASA,CAAK,EAAUL,EAAAA,aAAaW,CAAO,EACpEV,EAAAA,aAAaoB,EAAQ,CAAE,SAAU,UAAW,sBAAuB,CAAE,CAAC,CAAC,CAAC,OAAOhB,CAAK,CAC/F,C"}

package/dist/utils/numbers.js.map

@@ -1 +1 @@
-{"version":3,"file":"numbers.js","names":[],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":";;;AAUA,SAAgB,EAAM,GAAe,GAAa,GAAqB;CACnE,IAAI,OAAO,MAAM,CAAK,GAAG,OAAO;CAChC,IAAI,IAAM,GAAK;EACX,IAAM,IAAO;EAEb,AADA,IAAM,GACN,IAAM;CACV;CAGA,OAFI,IAAQ,IAAY,IACpB,IAAQ,IAAY,IACjB;AACX;AAqBA,SAAgB,EACZ,GACA,IAAmB,GACnB,GACM;CACN,IAAI,EAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAK,GAAG,OAAO,EAAa,CAAO;CAC3E,IAAI,MAAU,GAAG,OAAO;CAExB,IAAM,IAAQ;EAAC;EAAK;EAAM;EAAM;EAAM;CAAI,GACpC,IAAO,MACP,IAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,CAAK,CAAC,IAAI,KAAK,IAAI,CAAI,CAAC,GACrD,EAAM,SAAS,CACnB,GACM,IAAQ,IAAQ,KAAQ,GACxB,IAAS,MAAa,IAAI,IAAI,KAAK,IAAI,GAAG,CAAQ;CAGxD,OAAO,GAFW,WAAW,EAAM,QAAQ,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAG,EAAM;AACjC;AA2BA,SAAgB,EAAU,GAAc,GAAuB;CAE3D,OADI,CAAC,OAAO,SAAS,CAAI,KAAK,CAAC,OAAO,SAAS,CAAK,KAAK,MAAU,IAAU,IACrE,IAAO,IAAS;AAC5B;AAkBA,SAAgB,EACZ,GACA,IAAiB,SACjB,GACM;CAEN,OADI,EAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAK,IAAU,EAAa,CAAO,IACpE,EAAa,GAAQ;EAAE,UAAU;EAAW,uBAAuB;CAAE,CAAC,CAAC,CAAC,OAAO,CAAK;AAC/F"}
+{"version":3,"file":"numbers.js","names":["clamp","value","min","max","swap","formatBytes","isAbsent","bytes","fallbackText","options","units","base","exponent","digits","decimals","percentOf","part","total","formatCompactNumber","numberFormat","locale"],"sources":["../../src/utils/numbers.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { numberFormat } from \"@/utils/intl-cache\";\n/**\n * Clamp `value` between `min` and `max` (inclusive).\n *\n * @example\n * clamp(120, 0, 100); // 100\n * clamp(-5, 0, 100);  // 0\n * clamp(42, 0, 100);  // 42\n */\nexport function clamp(value: number, min: number, max: number): number {\n    if (Number.isNaN(value)) return value;\n    if (min > max) {\n        const swap = min;\n        min = max;\n        max = swap;\n    }\n    if (value < min) return min;\n    if (value > max) return max;\n    return value;\n}\n\n/**\n * Format a byte count as a human-readable size string.\n *\n * Scales through B, KB, MB, GB and TB using 1024 as the base. `decimals`\n * controls the fractional digits for scaled units (default 1); `0` bytes\n * always renders as `\"0 B\"`.\n *\n * An absent or unrepresentable count renders as `\"—\"`. It used to render as\n * **`\"NaN undefined\"`**: `Math.log(NaN)` walks the exponent off the end of the\n * unit table, so the unit itself came out `undefined` — the size was not merely\n * unreadable, it claimed a unit that does not exist.\n *\n * @example\n * formatBytes(0);       // \"0 B\"\n * formatBytes(1536);    // \"1.5 KB\"\n * formatBytes(1048576); // \"1 MB\"\n * formatBytes(1536, 2); // \"1.50 KB\"\n * formatBytes(null);    // \"—\"\n */\nexport function formatBytes(\n    bytes: number | null | undefined,\n    decimals: number = 1,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(bytes) || !Number.isFinite(bytes)) return fallbackText(options);\n    if (bytes === 0) return \"0 B\";\n\n    const units = [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const base = 1024;\n    const exponent = Math.min(\n        Math.floor(Math.log(Math.abs(bytes)) / Math.log(base)),\n        units.length - 1,\n    );\n    const value = bytes / base ** exponent;\n    const digits = exponent === 0 ? 0 : Math.max(0, decimals);\n    const formatted = parseFloat(value.toFixed(digits)).toString();\n\n    return `${formatted} ${units[exponent]}`;\n}\n\n/**\n * What percentage of `total` is `part`, with an empty base yielding `0`.\n *\n * The guard is the whole point: `(part / total) * 100` produces `NaN` when the\n * base is zero and `Infinity` when only the base is missing, and both reach the\n * screen as a broken label — `NaN%` on an empty dashboard is the single most\n * common way a panel announces that it has no data yet.\n *\n * Returns a **0–100** number, which is what a bar width and a label want.\n * `formatPercent` takes a 0–1 fraction instead, so pair them as\n * `formatPercent(percentOf(a, b) / 100)` — or skip `percentOf` and pass the\n * fraction straight in.\n *\n * The result is not clamped: 120% of a target is a real number somebody wants to\n * see, and capping it would hide the interesting case.\n *\n * @example\n * percentOf(3, 4);  // 75\n * percentOf(5, 0);  // 0\n * percentOf(12, 8); // 150\n *\n * @param part - The measured amount.\n * @param total - The base it is measured against.\n * @returns The percentage, or `0` when the base is zero or either input is not finite.\n */\nexport function percentOf(part: number, total: number): number {\n    if (!Number.isFinite(part) || !Number.isFinite(total) || total === 0) return 0;\n    return (part / total) * 100;\n}\n\n/**\n * Format a number using compact notation (e.g. `1.2K`, `3.4M`).\n *\n * Wraps `Intl.NumberFormat` with `notation: \"compact\"`. The `locale` defaults\n * to `\"en-US\"`.\n *\n * An absent or unrepresentable value renders as `\"—\"`. The `null` case is the\n * one that matters: `Intl` coerces it to zero, so a count the backend left out\n * used to read as **`\"0\"`** — a number the reader has no reason to doubt.\n *\n * @example\n * formatCompactNumber(1234);            // \"1.2K\"\n * formatCompactNumber(5600000);         // \"5.6M\"\n * formatCompactNumber(1234, \"pt-BR\");   // \"1,2 mil\"\n * formatCompactNumber(null);            // \"—\"\n */\nexport function formatCompactNumber(\n    value: number | null | undefined,\n    locale: string = \"en-US\",\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(locale, { notation: \"compact\", maximumFractionDigits: 1 }).format(value);\n}\n"],"mappings":";;;AAUA,SAAgBA,EAAM,GAAe,GAAa,GAAqB;CACnE,IAAI,OAAO,MAAMC,CAAK,GAAG,OAAOA;CAChC,IAAIC,IAAMC,GAAK;EACX,IAAMC,IAAOF;EAEb,AADA,IAAMC,GACN,IAAMC;CACV;CAGA,OAFIH,IAAQC,IAAYA,IACpBD,IAAQE,IAAYA,IACjBF;AACX;AAqBA,SAAgBI,EACZ,GACA,IAAmB,GACnB,GACM;CACN,IAAIC,EAASC,CAAK,KAAK,CAAC,OAAO,SAASA,CAAK,GAAG,OAAOC,EAAaC,CAAO;CAC3E,IAAIF,MAAU,GAAG,OAAO;CAExB,IAAMG,IAAQ;EAAC;EAAK;EAAM;EAAM;EAAM;CAAI,GACpCC,IAAO,MACPC,IAAW,KAAK,IAClB,KAAK,MAAM,KAAK,IAAI,KAAK,IAAIL,CAAK,CAAC,IAAI,KAAK,IAAII,CAAI,CAAC,GACrDD,EAAM,SAAS,CACnB,GACMT,IAAQM,IAAQI,KAAQC,GACxBC,IAASD,MAAa,IAAI,IAAI,KAAK,IAAI,GAAGE,CAAQ;CAGxD,OAAO,GAFW,WAAWb,EAAM,QAAQY,CAAM,CAAC,CAAC,CAAC,SAE1C,EAAU,GAAGH,EAAME;AACjC;AA2BA,SAAgBG,EAAU,GAAc,GAAuB;CAE3D,OADI,CAAC,OAAO,SAASC,CAAI,KAAK,CAAC,OAAO,SAASC,CAAK,KAAKA,MAAU,IAAU,IACrED,IAAOC,IAAS;AAC5B;AAkBA,SAAgBC,EACZ,GACA,IAAiB,SACjB,GACM;CAEN,OADIZ,EAASL,CAAK,KAAK,CAAC,OAAO,SAASA,CAAK,IAAUO,EAAaC,CAAO,IACpEU,EAAaC,GAAQ;EAAE,UAAU;EAAW,uBAAuB;CAAE,CAAC,CAAC,CAAC,OAAOnB,CAAK;AAC/F"}

package/dist/utils/objects.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"objects.cjs","names":[],"sources":["../../src/utils/objects.ts"],"sourcesContent":["/**\n * Determine whether a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances.\n *\n * @internal\n */\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Create a new object containing only the given `keys` from `obj`.\n *\n * Missing keys are skipped. The input is never mutated.\n *\n * @example\n * pick({ id: 1, name: \"Ana\", age: 30 }, [\"id\", \"name\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n/**\n * Create a new object with the given `keys` removed from `obj`.\n *\n * The input is never mutated.\n *\n * @example\n * omit({ id: 1, name: \"Ana\", age: 30 }, [\"age\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const exclude = new Set<PropertyKey>(keys);\n    const result = {} as Record<PropertyKey, unknown>;\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        if (!exclude.has(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result as Omit<T, K>;\n}\n\n/**\n * Recursively merge `source` into `target`, returning a new object.\n *\n * - Plain objects are merged key by key, recursing into nested plain objects.\n * - Arrays and non-plain values (dates, class instances, primitives) replace\n *   the target value entirely — they are not merged element by element.\n * - Neither `target` nor `source` is mutated.\n *\n * @example\n * deepMerge(\n *   { a: 1, nested: { x: 1, y: 2 } },\n *   { nested: { y: 20, z: 30 } },\n * );\n * // { a: 1, nested: { x: 1, y: 20, z: 30 } }\n *\n * @example\n * deepMerge({ tags: [\"a\", \"b\"] }, { tags: [\"c\"] });\n * // { tags: [\"c\"] } (arrays replaced, not merged)\n */\nexport function deepMerge<T>(target: T, source: Partial<T>): T {\n    if (!isPlainRecord(target) || !isPlainRecord(source)) {\n        return (source === undefined ? target : (source as unknown as T)) as T;\n    }\n    const result: Record<string, unknown> = { ...target };\n    for (const key of Object.keys(source)) {\n        const sourceValue = (source as Record<string, unknown>)[key];\n        const targetValue = result[key];\n        if (isPlainRecord(targetValue) && isPlainRecord(sourceValue)) {\n            result[key] = deepMerge(targetValue, sourceValue);\n        } else {\n            result[key] = sourceValue;\n        }\n    }\n    return result as T;\n}\n\n/**\n * Check whether a value is considered \"empty\".\n *\n * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty\n * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers\n * (including `0` and `NaN`), booleans, and dates, which are never empty.\n *\n * @example\n * isEmpty(null);       // true\n * isEmpty(\"\");         // true\n * isEmpty([]);         // true\n * isEmpty({});         // true\n * isEmpty(new Map());  // true\n * isEmpty(0);          // false\n * isEmpty(false);      // false\n * isEmpty(new Date()); // false\n */\nexport function isEmpty(value: unknown): boolean {\n    if (value === null || value === undefined) return true;\n    if (typeof value === \"string\") return value.length === 0;\n    if (Array.isArray(value)) return value.length === 0;\n    if (value instanceof Map || value instanceof Set) return value.size === 0;\n    if (isPlainRecord(value)) return Object.keys(value).length === 0;\n    return false;\n}\n"],"mappings":"AAOA,SAAS,EAAc,EAAkD,CACrE,GAAI,OAAO,GAAU,WAAY,EAAgB,MAAO,GACxD,IAAM,EAAQ,OAAO,eAAe,CAAK,EACzC,OAAO,IAAU,OAAO,WAAa,IAAU,IACnD,CAWA,SAAgB,EAA0C,EAAQ,EAAuB,CACrF,IAAM,EAAS,CAAC,EAChB,IAAK,IAAM,KAAO,EACV,OAAO,UAAU,eAAe,KAAK,EAAK,CAAG,IAC7C,EAAO,GAAO,EAAI,IAG1B,OAAO,CACX,CAWA,SAAgB,EAA0C,EAAQ,EAAuB,CACrF,IAAM,EAAU,IAAI,IAAiB,CAAI,EACnC,EAAS,CAAC,EAChB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAG,EACxB,EAAQ,IAAI,CAAG,IAChB,EAAO,GAAO,EAAI,IAG1B,OAAO,CACX,CAqBA,SAAgB,EAAa,EAAW,EAAuB,CAC3D,GAAI,CAAC,EAAc,CAAM,GAAK,CAAC,EAAc,CAAM,EAC/C,OAAQ,IAAW,IAAA,GAAY,EAAU,EAE7C,IAAM,EAAkC,CAAE,GAAG,CAAO,EACpD,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAAG,CACnC,IAAM,EAAe,EAAmC,GAClD,EAAc,EAAO,GAC3B,AAGI,EAAO,GAHP,EAAc,CAAW,GAAK,EAAc,CAAW,EACzC,EAAU,EAAa,CAAW,EAElC,CAEtB,CACA,OAAO,CACX,CAmBA,SAAgB,EAAQ,EAAyB,CAM7C,OALI,GAAU,KAAoC,GAC9C,OAAO,GAAU,UACjB,MAAM,QAAQ,CAAK,EAAU,EAAM,SAAW,EAC9C,aAAiB,KAAO,aAAiB,IAAY,EAAM,OAAS,EACpE,EAAc,CAAK,EAAU,OAAO,KAAK,CAAK,CAAC,CAAC,SAAW,EACxD,EACX"}
+{"version":3,"file":"objects.cjs","names":["isPlainRecord","value","proto","pick","result","key","keys","obj","omit","exclude","deepMerge","target","source","sourceValue","targetValue","isEmpty"],"sources":["../../src/utils/objects.ts"],"sourcesContent":["/**\n * Determine whether a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances.\n *\n * @internal\n */\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Create a new object containing only the given `keys` from `obj`.\n *\n * Missing keys are skipped. The input is never mutated.\n *\n * @example\n * pick({ id: 1, name: \"Ana\", age: 30 }, [\"id\", \"name\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n/**\n * Create a new object with the given `keys` removed from `obj`.\n *\n * The input is never mutated.\n *\n * @example\n * omit({ id: 1, name: \"Ana\", age: 30 }, [\"age\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const exclude = new Set<PropertyKey>(keys);\n    const result = {} as Record<PropertyKey, unknown>;\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        if (!exclude.has(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result as Omit<T, K>;\n}\n\n/**\n * Recursively merge `source` into `target`, returning a new object.\n *\n * - Plain objects are merged key by key, recursing into nested plain objects.\n * - Arrays and non-plain values (dates, class instances, primitives) replace\n *   the target value entirely — they are not merged element by element.\n * - Neither `target` nor `source` is mutated.\n *\n * @example\n * deepMerge(\n *   { a: 1, nested: { x: 1, y: 2 } },\n *   { nested: { y: 20, z: 30 } },\n * );\n * // { a: 1, nested: { x: 1, y: 20, z: 30 } }\n *\n * @example\n * deepMerge({ tags: [\"a\", \"b\"] }, { tags: [\"c\"] });\n * // { tags: [\"c\"] } (arrays replaced, not merged)\n */\nexport function deepMerge<T>(target: T, source: Partial<T>): T {\n    if (!isPlainRecord(target) || !isPlainRecord(source)) {\n        return (source === undefined ? target : (source as unknown as T)) as T;\n    }\n    const result: Record<string, unknown> = { ...target };\n    for (const key of Object.keys(source)) {\n        const sourceValue = (source as Record<string, unknown>)[key];\n        const targetValue = result[key];\n        if (isPlainRecord(targetValue) && isPlainRecord(sourceValue)) {\n            result[key] = deepMerge(targetValue, sourceValue);\n        } else {\n            result[key] = sourceValue;\n        }\n    }\n    return result as T;\n}\n\n/**\n * Check whether a value is considered \"empty\".\n *\n * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty\n * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers\n * (including `0` and `NaN`), booleans, and dates, which are never empty.\n *\n * @example\n * isEmpty(null);       // true\n * isEmpty(\"\");         // true\n * isEmpty([]);         // true\n * isEmpty({});         // true\n * isEmpty(new Map());  // true\n * isEmpty(0);          // false\n * isEmpty(false);      // false\n * isEmpty(new Date()); // false\n */\nexport function isEmpty(value: unknown): boolean {\n    if (value === null || value === undefined) return true;\n    if (typeof value === \"string\") return value.length === 0;\n    if (Array.isArray(value)) return value.length === 0;\n    if (value instanceof Map || value instanceof Set) return value.size === 0;\n    if (isPlainRecord(value)) return Object.keys(value).length === 0;\n    return false;\n}\n"],"mappings":"AAOA,SAASA,EAAc,EAAkD,CACrE,GAAI,OAAOC,GAAU,WAAYA,EAAgB,MAAO,GACxD,IAAMC,EAAQ,OAAO,eAAeD,CAAK,EACzC,OAAOC,IAAU,OAAO,WAAaA,IAAU,IACnD,CAWA,SAAgBC,EAA0C,EAAQ,EAAuB,CACrF,IAAMC,EAAS,CAAC,EAChB,IAAK,IAAMC,KAAOC,EACV,OAAO,UAAU,eAAe,KAAKC,EAAKF,CAAG,IAC7C,EAAOA,GAAOE,EAAIF,IAG1B,OAAOD,CACX,CAWA,SAAgBI,EAA0C,EAAQ,EAAuB,CACrF,IAAMC,EAAU,IAAI,IAAiBH,CAAI,EACnCF,EAAS,CAAC,EAChB,IAAK,IAAMC,KAAO,OAAO,KAAKE,CAAG,EACxBE,EAAQ,IAAIJ,CAAG,IAChB,EAAOA,GAAOE,EAAIF,IAG1B,OAAOD,CACX,CAqBA,SAAgBM,EAAa,EAAW,EAAuB,CAC3D,GAAI,CAACV,EAAcW,CAAM,GAAK,CAACX,EAAcY,CAAM,EAC/C,OAAQA,IAAW,IAAA,GAAYD,EAAUC,EAE7C,IAAMR,EAAkC,CAAE,GAAGO,CAAO,EACpD,IAAK,IAAMN,KAAO,OAAO,KAAKO,CAAM,EAAG,CACnC,IAAMC,EAAeD,EAAmCP,GAClDS,EAAcV,EAAOC,GAC3B,AAGID,EAAOC,GAHPL,EAAcc,CAAW,GAAKd,EAAca,CAAW,EACzCH,EAAUI,EAAaD,CAAW,EAElCA,CAEtB,CACA,OAAOT,CACX,CAmBA,SAAgBW,EAAQ,EAAyB,CAM7C,OALId,GAAU,KAAoC,GAC9C,OAAOA,GAAU,UACjB,MAAM,QAAQA,CAAK,EAAUA,EAAM,SAAW,EAC9CA,aAAiB,KAAOA,aAAiB,IAAYA,EAAM,OAAS,EACpED,EAAcC,CAAK,EAAU,OAAO,KAAKA,CAAK,CAAC,CAAC,SAAW,EACxD,EACX,C"}

package/dist/utils/objects.js.map

@@ -1 +1 @@
-{"version":3,"file":"objects.js","names":[],"sources":["../../src/utils/objects.ts"],"sourcesContent":["/**\n * Determine whether a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances.\n *\n * @internal\n */\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Create a new object containing only the given `keys` from `obj`.\n *\n * Missing keys are skipped. The input is never mutated.\n *\n * @example\n * pick({ id: 1, name: \"Ana\", age: 30 }, [\"id\", \"name\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n/**\n * Create a new object with the given `keys` removed from `obj`.\n *\n * The input is never mutated.\n *\n * @example\n * omit({ id: 1, name: \"Ana\", age: 30 }, [\"age\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const exclude = new Set<PropertyKey>(keys);\n    const result = {} as Record<PropertyKey, unknown>;\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        if (!exclude.has(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result as Omit<T, K>;\n}\n\n/**\n * Recursively merge `source` into `target`, returning a new object.\n *\n * - Plain objects are merged key by key, recursing into nested plain objects.\n * - Arrays and non-plain values (dates, class instances, primitives) replace\n *   the target value entirely — they are not merged element by element.\n * - Neither `target` nor `source` is mutated.\n *\n * @example\n * deepMerge(\n *   { a: 1, nested: { x: 1, y: 2 } },\n *   { nested: { y: 20, z: 30 } },\n * );\n * // { a: 1, nested: { x: 1, y: 20, z: 30 } }\n *\n * @example\n * deepMerge({ tags: [\"a\", \"b\"] }, { tags: [\"c\"] });\n * // { tags: [\"c\"] } (arrays replaced, not merged)\n */\nexport function deepMerge<T>(target: T, source: Partial<T>): T {\n    if (!isPlainRecord(target) || !isPlainRecord(source)) {\n        return (source === undefined ? target : (source as unknown as T)) as T;\n    }\n    const result: Record<string, unknown> = { ...target };\n    for (const key of Object.keys(source)) {\n        const sourceValue = (source as Record<string, unknown>)[key];\n        const targetValue = result[key];\n        if (isPlainRecord(targetValue) && isPlainRecord(sourceValue)) {\n            result[key] = deepMerge(targetValue, sourceValue);\n        } else {\n            result[key] = sourceValue;\n        }\n    }\n    return result as T;\n}\n\n/**\n * Check whether a value is considered \"empty\".\n *\n * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty\n * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers\n * (including `0` and `NaN`), booleans, and dates, which are never empty.\n *\n * @example\n * isEmpty(null);       // true\n * isEmpty(\"\");         // true\n * isEmpty([]);         // true\n * isEmpty({});         // true\n * isEmpty(new Map());  // true\n * isEmpty(0);          // false\n * isEmpty(false);      // false\n * isEmpty(new Date()); // false\n */\nexport function isEmpty(value: unknown): boolean {\n    if (value === null || value === undefined) return true;\n    if (typeof value === \"string\") return value.length === 0;\n    if (Array.isArray(value)) return value.length === 0;\n    if (value instanceof Map || value instanceof Set) return value.size === 0;\n    if (isPlainRecord(value)) return Object.keys(value).length === 0;\n    return false;\n}\n"],"mappings":";AAOA,SAAS,EAAc,GAAkD;CACrE,IAAI,OAAO,KAAU,aAAY,GAAgB,OAAO;CACxD,IAAM,IAAQ,OAAO,eAAe,CAAK;CACzC,OAAO,MAAU,OAAO,aAAa,MAAU;AACnD;AAWA,SAAgB,EAA0C,GAAQ,GAAuB;CACrF,IAAM,IAAS,CAAC;CAChB,KAAK,IAAM,KAAO,GACd,AAAI,OAAO,UAAU,eAAe,KAAK,GAAK,CAAG,MAC7C,EAAO,KAAO,EAAI;CAG1B,OAAO;AACX;AAWA,SAAgB,EAA0C,GAAQ,GAAuB;CACrF,IAAM,IAAU,IAAI,IAAiB,CAAI,GACnC,IAAS,CAAC;CAChB,KAAK,IAAM,KAAO,OAAO,KAAK,CAAG,GAC7B,AAAK,EAAQ,IAAI,CAAG,MAChB,EAAO,KAAO,EAAI;CAG1B,OAAO;AACX;AAqBA,SAAgB,EAAa,GAAW,GAAuB;CAC3D,IAAI,CAAC,EAAc,CAAM,KAAK,CAAC,EAAc,CAAM,GAC/C,OAAQ,MAAW,KAAA,IAAY,IAAU;CAE7C,IAAM,IAAkC,EAAE,GAAG,EAAO;CACpD,KAAK,IAAM,KAAO,OAAO,KAAK,CAAM,GAAG;EACnC,IAAM,IAAe,EAAmC,IAClD,IAAc,EAAO;EAC3B,AAGI,EAAO,KAHP,EAAc,CAAW,KAAK,EAAc,CAAW,IACzC,EAAU,GAAa,CAAW,IAElC;CAEtB;CACA,OAAO;AACX;AAmBA,SAAgB,EAAQ,GAAyB;CAM7C,OALI,KAAU,OAAoC,KAC9C,OAAO,KAAU,YACjB,MAAM,QAAQ,CAAK,IAAU,EAAM,WAAW,IAC9C,aAAiB,OAAO,aAAiB,MAAY,EAAM,SAAS,IACpE,EAAc,CAAK,IAAU,OAAO,KAAK,CAAK,CAAC,CAAC,WAAW,IACxD;AACX"}
+{"version":3,"file":"objects.js","names":["isPlainRecord","value","proto","pick","result","key","keys","obj","omit","exclude","deepMerge","target","source","sourceValue","targetValue","isEmpty"],"sources":["../../src/utils/objects.ts"],"sourcesContent":["/**\n * Determine whether a value is a plain object literal.\n *\n * Returns `false` for arrays, `null`, dates, maps, sets, and class instances.\n *\n * @internal\n */\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n    if (typeof value !== \"object\" || value === null) return false;\n    const proto = Object.getPrototypeOf(value);\n    return proto === Object.prototype || proto === null;\n}\n\n/**\n * Create a new object containing only the given `keys` from `obj`.\n *\n * Missing keys are skipped. The input is never mutated.\n *\n * @example\n * pick({ id: 1, name: \"Ana\", age: 30 }, [\"id\", \"name\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n/**\n * Create a new object with the given `keys` removed from `obj`.\n *\n * The input is never mutated.\n *\n * @example\n * omit({ id: 1, name: \"Ana\", age: 30 }, [\"age\"]);\n * // { id: 1, name: \"Ana\" }\n */\nexport function omit<T extends object, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n    const exclude = new Set<PropertyKey>(keys);\n    const result = {} as Record<PropertyKey, unknown>;\n    for (const key of Object.keys(obj) as (keyof T)[]) {\n        if (!exclude.has(key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result as Omit<T, K>;\n}\n\n/**\n * Recursively merge `source` into `target`, returning a new object.\n *\n * - Plain objects are merged key by key, recursing into nested plain objects.\n * - Arrays and non-plain values (dates, class instances, primitives) replace\n *   the target value entirely — they are not merged element by element.\n * - Neither `target` nor `source` is mutated.\n *\n * @example\n * deepMerge(\n *   { a: 1, nested: { x: 1, y: 2 } },\n *   { nested: { y: 20, z: 30 } },\n * );\n * // { a: 1, nested: { x: 1, y: 20, z: 30 } }\n *\n * @example\n * deepMerge({ tags: [\"a\", \"b\"] }, { tags: [\"c\"] });\n * // { tags: [\"c\"] } (arrays replaced, not merged)\n */\nexport function deepMerge<T>(target: T, source: Partial<T>): T {\n    if (!isPlainRecord(target) || !isPlainRecord(source)) {\n        return (source === undefined ? target : (source as unknown as T)) as T;\n    }\n    const result: Record<string, unknown> = { ...target };\n    for (const key of Object.keys(source)) {\n        const sourceValue = (source as Record<string, unknown>)[key];\n        const targetValue = result[key];\n        if (isPlainRecord(targetValue) && isPlainRecord(sourceValue)) {\n            result[key] = deepMerge(targetValue, sourceValue);\n        } else {\n            result[key] = sourceValue;\n        }\n    }\n    return result as T;\n}\n\n/**\n * Check whether a value is considered \"empty\".\n *\n * Returns `true` for `null`, `undefined`, empty strings, empty arrays, empty\n * plain objects, and empty `Map`/`Set` instances. Returns `false` for numbers\n * (including `0` and `NaN`), booleans, and dates, which are never empty.\n *\n * @example\n * isEmpty(null);       // true\n * isEmpty(\"\");         // true\n * isEmpty([]);         // true\n * isEmpty({});         // true\n * isEmpty(new Map());  // true\n * isEmpty(0);          // false\n * isEmpty(false);      // false\n * isEmpty(new Date()); // false\n */\nexport function isEmpty(value: unknown): boolean {\n    if (value === null || value === undefined) return true;\n    if (typeof value === \"string\") return value.length === 0;\n    if (Array.isArray(value)) return value.length === 0;\n    if (value instanceof Map || value instanceof Set) return value.size === 0;\n    if (isPlainRecord(value)) return Object.keys(value).length === 0;\n    return false;\n}\n"],"mappings":";AAOA,SAASA,EAAc,GAAkD;CACrE,IAAI,OAAOC,KAAU,aAAYA,GAAgB,OAAO;CACxD,IAAMC,IAAQ,OAAO,eAAeD,CAAK;CACzC,OAAOC,MAAU,OAAO,aAAaA,MAAU;AACnD;AAWA,SAAgBC,EAA0C,GAAQ,GAAuB;CACrF,IAAMC,IAAS,CAAC;CAChB,KAAK,IAAMC,KAAOC,GACd,AAAI,OAAO,UAAU,eAAe,KAAKC,GAAKF,CAAG,MAC7C,EAAOA,KAAOE,EAAIF;CAG1B,OAAOD;AACX;AAWA,SAAgBI,EAA0C,GAAQ,GAAuB;CACrF,IAAMC,IAAU,IAAI,IAAiBH,CAAI,GACnCF,IAAS,CAAC;CAChB,KAAK,IAAMC,KAAO,OAAO,KAAKE,CAAG,GAC7B,AAAKE,EAAQ,IAAIJ,CAAG,MAChB,EAAOA,KAAOE,EAAIF;CAG1B,OAAOD;AACX;AAqBA,SAAgBM,EAAa,GAAW,GAAuB;CAC3D,IAAI,CAACV,EAAcW,CAAM,KAAK,CAACX,EAAcY,CAAM,GAC/C,OAAQA,MAAW,KAAA,IAAYD,IAAUC;CAE7C,IAAMR,IAAkC,EAAE,GAAGO,EAAO;CACpD,KAAK,IAAMN,KAAO,OAAO,KAAKO,CAAM,GAAG;EACnC,IAAMC,IAAeD,EAAmCP,IAClDS,IAAcV,EAAOC;EAC3B,AAGID,EAAOC,KAHPL,EAAcc,CAAW,KAAKd,EAAca,CAAW,IACzCH,EAAUI,GAAaD,CAAW,IAElCA;CAEtB;CACA,OAAOT;AACX;AAmBA,SAAgBW,EAAQ,GAAyB;CAM7C,OALId,KAAU,OAAoC,KAC9C,OAAOA,KAAU,YACjB,MAAM,QAAQA,CAAK,IAAUA,EAAM,WAAW,IAC9CA,aAAiB,OAAOA,aAAiB,MAAYA,EAAM,SAAS,IACpED,EAAcC,CAAK,IAAU,OAAO,KAAKA,CAAK,CAAC,CAAC,WAAW,IACxD;AACX"}

package/dist/utils/owner-fingerprint.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"owner-fingerprint.cjs","names":[],"sources":["../../src/utils/owner-fingerprint.ts"],"sourcesContent":["/**\n * FNV-1a 32-bit offset basis, the seed of the first half of the fingerprint.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `offset_basis` for 32 bits).\n */\nexport const FNV_OFFSET_BASIS_32 = 0x811c9dc5;\n\n/**\n * FNV-1a 32-bit prime.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `FNV_prime` for 32 bits).\n */\nexport const FNV_PRIME_32 = 0x01000193;\n\n/**\n * Seed of the second half of the fingerprint: the basis with every bit\n * flipped, so the two halves are independent hashes of the same text.\n */\nconst SECOND_SEED = ~FNV_OFFSET_BASIS_32 >>> 0;\n\n/**\n * Hash `text` with FNV-1a from `seed`.\n *\n * @param text - What to hash, read as UTF-16 code units.\n * @param seed - Starting value.\n * @returns The 32-bit hash as an unsigned integer.\n */\nfunction fnv1a(text: string, seed: number): number {\n    let hash = seed;\n    for (let index = 0; index < text.length; index += 1) {\n        hash ^= text.charCodeAt(index);\n        hash = Math.imul(hash, FNV_PRIME_32);\n    }\n    return hash >>> 0;\n}\n\n/**\n * A 64-bit one-way fingerprint of `text`, as 16 hex characters.\n *\n * Not a cryptographic hash, and it does not need to be: it only has to tell\n * two signed-in identities apart on one device, and it must not let anyone\n * holding a stored record send as the user. Sixty-four bits cannot be turned\n * back into a bearer token, and two different users colliding on one browser\n * is a one-in-2^64 event. A synchronous hash is what lets a caller such as the\n * error reporter's `report()` stamp the owner without awaiting\n * `crypto.subtle`.\n *\n * @param text - The principal or token to fingerprint.\n * @returns Sixteen lowercase hex characters.\n */\nexport function fingerprintOwner(text: string): string {\n    const first = fnv1a(text, FNV_OFFSET_BASIS_32).toString(16).padStart(8, \"0\");\n    const second = fnv1a(text, SECOND_SEED).toString(16).padStart(8, \"0\");\n    return `${first}${second}`;\n}\n\n/**\n * Turn a principal or a token into the fingerprint a persisted record stores —\n * an error-report queue entry, a resumable-upload record.\n *\n * The prefix keeps the two sources from ever matching each other: a record\n * stamped from a principal is never taken for one stamped from a token.\n *\n * Only a non-empty string or a finite number is an identity. Anything else —\n * notably the `Promise` an `async` getter returns from untyped JS — reads as\n * nobody, because stringifying it would give every user the same\n * `\"[object Promise]\"` fingerprint.\n *\n * @param source - `\"p\"` for a principal from `getPrincipal`, `\"t\"` for a token.\n * @param value - The identity, or nothing when nobody is signed in.\n * @returns `\"<source>:<fingerprint>\"`, or `null` when `value` is no identity.\n */\nexport function ownerFingerprint(source: \"p\" | \"t\", value: unknown): string | null {\n    const text =\n        typeof value === \"string\"\n            ? value\n            : typeof value === \"number\" && Number.isFinite(value)\n              ? String(value)\n              : \"\";\n    return text ? `${source}:${fingerprintOwner(text)}` : null;\n}\n"],"mappings":"AAKA,IAAa,EAAsB,WAOtB,EAAe,SAe5B,SAAS,EAAM,EAAc,EAAsB,CAC/C,IAAI,EAAO,EACX,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAK,OAAQ,GAAS,EAC9C,GAAQ,EAAK,WAAW,CAAK,EAC7B,EAAO,KAAK,KAAK,EAAM,CAAY,EAEvC,OAAO,IAAS,CACpB,CAgBA,SAAgB,EAAiB,EAAsB,CAGnD,MAAO,GAFO,EAAM,EAAM,CAAmB,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAE9D,IADK,EAAM,EAAM,UAAW,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAC/C,GACtB,CAkBA,SAAgB,EAAiB,EAAmB,EAA+B,CAC/E,IAAM,EACF,OAAO,GAAU,SACX,EACA,OAAO,GAAU,UAAY,OAAO,SAAS,CAAK,EAChD,OAAO,CAAK,EACZ,GACZ,OAAO,EAAO,GAAG,EAAO,GAAG,EAAiB,CAAI,IAAM,IAC1D"}
+{"version":3,"file":"owner-fingerprint.cjs","names":["FNV_OFFSET_BASIS_32","FNV_PRIME_32","fnv1a","hash","seed","index","text","fingerprintOwner","ownerFingerprint","value","source"],"sources":["../../src/utils/owner-fingerprint.ts"],"sourcesContent":["/**\n * FNV-1a 32-bit offset basis, the seed of the first half of the fingerprint.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `offset_basis` for 32 bits).\n */\nexport const FNV_OFFSET_BASIS_32 = 0x811c9dc5;\n\n/**\n * FNV-1a 32-bit prime.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `FNV_prime` for 32 bits).\n */\nexport const FNV_PRIME_32 = 0x01000193;\n\n/**\n * Seed of the second half of the fingerprint: the basis with every bit\n * flipped, so the two halves are independent hashes of the same text.\n */\nconst SECOND_SEED = ~FNV_OFFSET_BASIS_32 >>> 0;\n\n/**\n * Hash `text` with FNV-1a from `seed`.\n *\n * @param text - What to hash, read as UTF-16 code units.\n * @param seed - Starting value.\n * @returns The 32-bit hash as an unsigned integer.\n */\nfunction fnv1a(text: string, seed: number): number {\n    let hash = seed;\n    for (let index = 0; index < text.length; index += 1) {\n        hash ^= text.charCodeAt(index);\n        hash = Math.imul(hash, FNV_PRIME_32);\n    }\n    return hash >>> 0;\n}\n\n/**\n * A 64-bit one-way fingerprint of `text`, as 16 hex characters.\n *\n * Not a cryptographic hash, and it does not need to be: it only has to tell\n * two signed-in identities apart on one device, and it must not let anyone\n * holding a stored record send as the user. Sixty-four bits cannot be turned\n * back into a bearer token, and two different users colliding on one browser\n * is a one-in-2^64 event. A synchronous hash is what lets a caller such as the\n * error reporter's `report()` stamp the owner without awaiting\n * `crypto.subtle`.\n *\n * @param text - The principal or token to fingerprint.\n * @returns Sixteen lowercase hex characters.\n */\nexport function fingerprintOwner(text: string): string {\n    const first = fnv1a(text, FNV_OFFSET_BASIS_32).toString(16).padStart(8, \"0\");\n    const second = fnv1a(text, SECOND_SEED).toString(16).padStart(8, \"0\");\n    return `${first}${second}`;\n}\n\n/**\n * Turn a principal or a token into the fingerprint a persisted record stores —\n * an error-report queue entry, a resumable-upload record.\n *\n * The prefix keeps the two sources from ever matching each other: a record\n * stamped from a principal is never taken for one stamped from a token.\n *\n * Only a non-empty string or a finite number is an identity. Anything else —\n * notably the `Promise` an `async` getter returns from untyped JS — reads as\n * nobody, because stringifying it would give every user the same\n * `\"[object Promise]\"` fingerprint.\n *\n * @param source - `\"p\"` for a principal from `getPrincipal`, `\"t\"` for a token.\n * @param value - The identity, or nothing when nobody is signed in.\n * @returns `\"<source>:<fingerprint>\"`, or `null` when `value` is no identity.\n */\nexport function ownerFingerprint(source: \"p\" | \"t\", value: unknown): string | null {\n    const text =\n        typeof value === \"string\"\n            ? value\n            : typeof value === \"number\" && Number.isFinite(value)\n              ? String(value)\n              : \"\";\n    return text ? `${source}:${fingerprintOwner(text)}` : null;\n}\n"],"mappings":"AAKA,IAAaA,EAAsB,WAOtBC,EAAe,SAe5B,SAASC,EAAM,EAAc,EAAsB,CAC/C,IAAIC,EAAOC,EACX,IAAK,IAAIC,EAAQ,EAAGA,EAAQC,EAAK,OAAQ,GAAS,EAC9C,GAAQA,EAAK,WAAWD,CAAK,EAC7B,EAAO,KAAK,KAAKF,EAAMF,CAAY,EAEvC,OAAOE,IAAS,CACpB,CAgBA,SAAgBI,EAAiB,EAAsB,CAGnD,MAAO,GAFOL,EAAMI,EAAMN,CAAmB,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAE9D,IADKE,EAAMI,EAAM,UAAW,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAC/C,GACtB,CAkBA,SAAgBE,EAAiB,EAAmB,EAA+B,CAC/E,IAAMF,EACF,OAAOG,GAAU,SACXA,EACA,OAAOA,GAAU,UAAY,OAAO,SAASA,CAAK,EAChD,OAAOA,CAAK,EACZ,GACZ,OAAOH,EAAO,GAAGI,EAAO,GAAGH,EAAiBD,CAAI,IAAM,IAC1D,C"}

package/dist/utils/owner-fingerprint.js.map

@@ -1 +1 @@
-{"version":3,"file":"owner-fingerprint.js","names":[],"sources":["../../src/utils/owner-fingerprint.ts"],"sourcesContent":["/**\n * FNV-1a 32-bit offset basis, the seed of the first half of the fingerprint.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `offset_basis` for 32 bits).\n */\nexport const FNV_OFFSET_BASIS_32 = 0x811c9dc5;\n\n/**\n * FNV-1a 32-bit prime.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `FNV_prime` for 32 bits).\n */\nexport const FNV_PRIME_32 = 0x01000193;\n\n/**\n * Seed of the second half of the fingerprint: the basis with every bit\n * flipped, so the two halves are independent hashes of the same text.\n */\nconst SECOND_SEED = ~FNV_OFFSET_BASIS_32 >>> 0;\n\n/**\n * Hash `text` with FNV-1a from `seed`.\n *\n * @param text - What to hash, read as UTF-16 code units.\n * @param seed - Starting value.\n * @returns The 32-bit hash as an unsigned integer.\n */\nfunction fnv1a(text: string, seed: number): number {\n    let hash = seed;\n    for (let index = 0; index < text.length; index += 1) {\n        hash ^= text.charCodeAt(index);\n        hash = Math.imul(hash, FNV_PRIME_32);\n    }\n    return hash >>> 0;\n}\n\n/**\n * A 64-bit one-way fingerprint of `text`, as 16 hex characters.\n *\n * Not a cryptographic hash, and it does not need to be: it only has to tell\n * two signed-in identities apart on one device, and it must not let anyone\n * holding a stored record send as the user. Sixty-four bits cannot be turned\n * back into a bearer token, and two different users colliding on one browser\n * is a one-in-2^64 event. A synchronous hash is what lets a caller such as the\n * error reporter's `report()` stamp the owner without awaiting\n * `crypto.subtle`.\n *\n * @param text - The principal or token to fingerprint.\n * @returns Sixteen lowercase hex characters.\n */\nexport function fingerprintOwner(text: string): string {\n    const first = fnv1a(text, FNV_OFFSET_BASIS_32).toString(16).padStart(8, \"0\");\n    const second = fnv1a(text, SECOND_SEED).toString(16).padStart(8, \"0\");\n    return `${first}${second}`;\n}\n\n/**\n * Turn a principal or a token into the fingerprint a persisted record stores —\n * an error-report queue entry, a resumable-upload record.\n *\n * The prefix keeps the two sources from ever matching each other: a record\n * stamped from a principal is never taken for one stamped from a token.\n *\n * Only a non-empty string or a finite number is an identity. Anything else —\n * notably the `Promise` an `async` getter returns from untyped JS — reads as\n * nobody, because stringifying it would give every user the same\n * `\"[object Promise]\"` fingerprint.\n *\n * @param source - `\"p\"` for a principal from `getPrincipal`, `\"t\"` for a token.\n * @param value - The identity, or nothing when nobody is signed in.\n * @returns `\"<source>:<fingerprint>\"`, or `null` when `value` is no identity.\n */\nexport function ownerFingerprint(source: \"p\" | \"t\", value: unknown): string | null {\n    const text =\n        typeof value === \"string\"\n            ? value\n            : typeof value === \"number\" && Number.isFinite(value)\n              ? String(value)\n              : \"\";\n    return text ? `${source}:${fingerprintOwner(text)}` : null;\n}\n"],"mappings":";AAKA,IAAa,IAAsB,YAOtB,IAAe;AAe5B,SAAS,EAAM,GAAc,GAAsB;CAC/C,IAAI,IAAO;CACX,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAK,QAAQ,KAAS,GAE9C,AADA,KAAQ,EAAK,WAAW,CAAK,GAC7B,IAAO,KAAK,KAAK,GAAM,CAAY;CAEvC,OAAO,MAAS;AACpB;AAgBA,SAAgB,EAAiB,GAAsB;CAGnD,OAAO,GAFO,EAAM,GAAM,CAAmB,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAE9D,IADK,EAAM,GAAM,UAAW,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAC/C;AACtB;AAkBA,SAAgB,EAAiB,GAAmB,GAA+B;CAC/E,IAAM,IACF,OAAO,KAAU,WACX,IACA,OAAO,KAAU,YAAY,OAAO,SAAS,CAAK,IAChD,OAAO,CAAK,IACZ;CACZ,OAAO,IAAO,GAAG,EAAO,GAAG,EAAiB,CAAI,MAAM;AAC1D"}
+{"version":3,"file":"owner-fingerprint.js","names":["FNV_OFFSET_BASIS_32","FNV_PRIME_32","fnv1a","hash","seed","index","text","fingerprintOwner","ownerFingerprint","value","source"],"sources":["../../src/utils/owner-fingerprint.ts"],"sourcesContent":["/**\n * FNV-1a 32-bit offset basis, the seed of the first half of the fingerprint.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `offset_basis` for 32 bits).\n */\nexport const FNV_OFFSET_BASIS_32 = 0x811c9dc5;\n\n/**\n * FNV-1a 32-bit prime.\n *\n * Ported from the FNV specification (Fowler/Noll/Vo, `FNV_prime` for 32 bits).\n */\nexport const FNV_PRIME_32 = 0x01000193;\n\n/**\n * Seed of the second half of the fingerprint: the basis with every bit\n * flipped, so the two halves are independent hashes of the same text.\n */\nconst SECOND_SEED = ~FNV_OFFSET_BASIS_32 >>> 0;\n\n/**\n * Hash `text` with FNV-1a from `seed`.\n *\n * @param text - What to hash, read as UTF-16 code units.\n * @param seed - Starting value.\n * @returns The 32-bit hash as an unsigned integer.\n */\nfunction fnv1a(text: string, seed: number): number {\n    let hash = seed;\n    for (let index = 0; index < text.length; index += 1) {\n        hash ^= text.charCodeAt(index);\n        hash = Math.imul(hash, FNV_PRIME_32);\n    }\n    return hash >>> 0;\n}\n\n/**\n * A 64-bit one-way fingerprint of `text`, as 16 hex characters.\n *\n * Not a cryptographic hash, and it does not need to be: it only has to tell\n * two signed-in identities apart on one device, and it must not let anyone\n * holding a stored record send as the user. Sixty-four bits cannot be turned\n * back into a bearer token, and two different users colliding on one browser\n * is a one-in-2^64 event. A synchronous hash is what lets a caller such as the\n * error reporter's `report()` stamp the owner without awaiting\n * `crypto.subtle`.\n *\n * @param text - The principal or token to fingerprint.\n * @returns Sixteen lowercase hex characters.\n */\nexport function fingerprintOwner(text: string): string {\n    const first = fnv1a(text, FNV_OFFSET_BASIS_32).toString(16).padStart(8, \"0\");\n    const second = fnv1a(text, SECOND_SEED).toString(16).padStart(8, \"0\");\n    return `${first}${second}`;\n}\n\n/**\n * Turn a principal or a token into the fingerprint a persisted record stores —\n * an error-report queue entry, a resumable-upload record.\n *\n * The prefix keeps the two sources from ever matching each other: a record\n * stamped from a principal is never taken for one stamped from a token.\n *\n * Only a non-empty string or a finite number is an identity. Anything else —\n * notably the `Promise` an `async` getter returns from untyped JS — reads as\n * nobody, because stringifying it would give every user the same\n * `\"[object Promise]\"` fingerprint.\n *\n * @param source - `\"p\"` for a principal from `getPrincipal`, `\"t\"` for a token.\n * @param value - The identity, or nothing when nobody is signed in.\n * @returns `\"<source>:<fingerprint>\"`, or `null` when `value` is no identity.\n */\nexport function ownerFingerprint(source: \"p\" | \"t\", value: unknown): string | null {\n    const text =\n        typeof value === \"string\"\n            ? value\n            : typeof value === \"number\" && Number.isFinite(value)\n              ? String(value)\n              : \"\";\n    return text ? `${source}:${fingerprintOwner(text)}` : null;\n}\n"],"mappings":";AAKA,IAAaA,IAAsB,YAOtBC,IAAe;AAe5B,SAASC,EAAM,GAAc,GAAsB;CAC/C,IAAIC,IAAOC;CACX,KAAK,IAAIC,IAAQ,GAAGA,IAAQC,EAAK,QAAQ,KAAS,GAE9C,AADA,KAAQA,EAAK,WAAWD,CAAK,GAC7B,IAAO,KAAK,KAAKF,GAAMF,CAAY;CAEvC,OAAOE,MAAS;AACpB;AAgBA,SAAgBI,EAAiB,GAAsB;CAGnD,OAAO,GAFOL,EAAMI,GAAMN,CAAmB,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAE9D,IADKE,EAAMI,GAAM,UAAW,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAC/C;AACtB;AAkBA,SAAgBE,EAAiB,GAAmB,GAA+B;CAC/E,IAAMF,IACF,OAAOG,KAAU,WACXA,IACA,OAAOA,KAAU,YAAY,OAAO,SAASA,CAAK,IAChD,OAAOA,CAAK,IACZ;CACZ,OAAOH,IAAO,GAAGI,EAAO,GAAGH,EAAiBD,CAAI,MAAM;AAC1D"}

package/dist/utils/promises.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"promises.cjs","names":[],"sources":["../../src/utils/promises.ts"],"sourcesContent":["/**\n * Resolve after `ms` milliseconds.\n *\n * @example\n * await sleep(500); // pauses for half a second\n */\nexport function sleep(ms: number): Promise<void> {\n    return new Promise<void>((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Race `promise` against a timeout.\n *\n * Resolves/rejects with `promise` when it settles first. If `ms` elapses\n * before that, the returned promise rejects with an `Error` whose `name` is\n * `\"TimeoutError\"`.\n *\n * @example\n * await withTimeout(fetch(\"/slow\"), 3000);\n * await withTimeout(fetch(\"/slow\"), 3000, \"request too slow\");\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n        const timer = setTimeout(() => {\n            const error = new Error(message ?? `Operation timed out after ${ms}ms`);\n            error.name = \"TimeoutError\";\n            reject(error);\n        }, ms);\n\n        promise.then(\n            (value) => {\n                clearTimeout(timer);\n                resolve(value);\n            },\n            (reason) => {\n                clearTimeout(timer);\n                reject(reason);\n            },\n        );\n    });\n}\n"],"mappings":"AAMA,SAAgB,EAAM,EAA2B,CAC7C,OAAO,IAAI,QAAe,GAAY,WAAW,EAAS,CAAE,CAAC,CACjE,CAaA,SAAgB,EAAe,EAAqB,EAAY,EAA8B,CAC1F,OAAO,IAAI,SAAY,EAAS,IAAW,CACvC,IAAM,EAAQ,eAAiB,CAC3B,IAAM,EAAY,MAAM,GAAW,6BAA6B,EAAG,GAAG,EACtE,EAAM,KAAO,eACb,EAAO,CAAK,CAChB,EAAG,CAAE,EAEL,EAAQ,KACH,GAAU,CACP,aAAa,CAAK,EAClB,EAAQ,CAAK,CACjB,EACC,GAAW,CACR,aAAa,CAAK,EAClB,EAAO,CAAM,CACjB,CACJ,CACJ,CAAC,CACL"}
+{"version":3,"file":"promises.cjs","names":["sleep","resolve","ms","withTimeout","timer","error","message","reject","promise","value","reason"],"sources":["../../src/utils/promises.ts"],"sourcesContent":["/**\n * Resolve after `ms` milliseconds.\n *\n * @example\n * await sleep(500); // pauses for half a second\n */\nexport function sleep(ms: number): Promise<void> {\n    return new Promise<void>((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Race `promise` against a timeout.\n *\n * Resolves/rejects with `promise` when it settles first. If `ms` elapses\n * before that, the returned promise rejects with an `Error` whose `name` is\n * `\"TimeoutError\"`.\n *\n * @example\n * await withTimeout(fetch(\"/slow\"), 3000);\n * await withTimeout(fetch(\"/slow\"), 3000, \"request too slow\");\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n        const timer = setTimeout(() => {\n            const error = new Error(message ?? `Operation timed out after ${ms}ms`);\n            error.name = \"TimeoutError\";\n            reject(error);\n        }, ms);\n\n        promise.then(\n            (value) => {\n                clearTimeout(timer);\n                resolve(value);\n            },\n            (reason) => {\n                clearTimeout(timer);\n                reject(reason);\n            },\n        );\n    });\n}\n"],"mappings":"AAMA,SAAgBA,EAAM,EAA2B,CAC7C,OAAO,IAAI,QAAe,GAAY,WAAWC,EAASC,CAAE,CAAC,CACjE,CAaA,SAAgBC,EAAe,EAAqB,EAAY,EAA8B,CAC1F,OAAO,IAAI,SAAY,EAAS,IAAW,CACvC,IAAMC,EAAQ,eAAiB,CAC3B,IAAMC,EAAY,MAAMC,GAAW,6BAA6BJ,EAAG,GAAG,EACtE,EAAM,KAAO,eACbK,EAAOF,CAAK,CAChB,EAAGH,CAAE,EAELM,EAAQ,KACH,GAAU,CACP,aAAaJ,CAAK,EAClBH,EAAQQ,CAAK,CACjB,EACC,GAAW,CACR,aAAaL,CAAK,EAClBG,EAAOG,CAAM,CACjB,CACJ,CACJ,CAAC,CACL,C"}

package/dist/utils/promises.js.map

@@ -1 +1 @@
-{"version":3,"file":"promises.js","names":[],"sources":["../../src/utils/promises.ts"],"sourcesContent":["/**\n * Resolve after `ms` milliseconds.\n *\n * @example\n * await sleep(500); // pauses for half a second\n */\nexport function sleep(ms: number): Promise<void> {\n    return new Promise<void>((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Race `promise` against a timeout.\n *\n * Resolves/rejects with `promise` when it settles first. If `ms` elapses\n * before that, the returned promise rejects with an `Error` whose `name` is\n * `\"TimeoutError\"`.\n *\n * @example\n * await withTimeout(fetch(\"/slow\"), 3000);\n * await withTimeout(fetch(\"/slow\"), 3000, \"request too slow\");\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n        const timer = setTimeout(() => {\n            const error = new Error(message ?? `Operation timed out after ${ms}ms`);\n            error.name = \"TimeoutError\";\n            reject(error);\n        }, ms);\n\n        promise.then(\n            (value) => {\n                clearTimeout(timer);\n                resolve(value);\n            },\n            (reason) => {\n                clearTimeout(timer);\n                reject(reason);\n            },\n        );\n    });\n}\n"],"mappings":";AAMA,SAAgB,EAAM,GAA2B;CAC7C,OAAO,IAAI,SAAe,MAAY,WAAW,GAAS,CAAE,CAAC;AACjE;AAaA,SAAgB,EAAe,GAAqB,GAAY,GAA8B;CAC1F,OAAO,IAAI,SAAY,GAAS,MAAW;EACvC,IAAM,IAAQ,iBAAiB;GAC3B,IAAM,IAAY,MAAM,KAAW,6BAA6B,EAAG,GAAG;GAEtE,AADA,EAAM,OAAO,gBACb,EAAO,CAAK;EAChB,GAAG,CAAE;EAEL,EAAQ,MACH,MAAU;GAEP,AADA,aAAa,CAAK,GAClB,EAAQ,CAAK;EACjB,IACC,MAAW;GAER,AADA,aAAa,CAAK,GAClB,EAAO,CAAM;EACjB,CACJ;CACJ,CAAC;AACL"}
+{"version":3,"file":"promises.js","names":["sleep","resolve","ms","withTimeout","timer","error","message","reject","value","reason"],"sources":["../../src/utils/promises.ts"],"sourcesContent":["/**\n * Resolve after `ms` milliseconds.\n *\n * @example\n * await sleep(500); // pauses for half a second\n */\nexport function sleep(ms: number): Promise<void> {\n    return new Promise<void>((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Race `promise` against a timeout.\n *\n * Resolves/rejects with `promise` when it settles first. If `ms` elapses\n * before that, the returned promise rejects with an `Error` whose `name` is\n * `\"TimeoutError\"`.\n *\n * @example\n * await withTimeout(fetch(\"/slow\"), 3000);\n * await withTimeout(fetch(\"/slow\"), 3000, \"request too slow\");\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n        const timer = setTimeout(() => {\n            const error = new Error(message ?? `Operation timed out after ${ms}ms`);\n            error.name = \"TimeoutError\";\n            reject(error);\n        }, ms);\n\n        promise.then(\n            (value) => {\n                clearTimeout(timer);\n                resolve(value);\n            },\n            (reason) => {\n                clearTimeout(timer);\n                reject(reason);\n            },\n        );\n    });\n}\n"],"mappings":";AAMA,SAAgBA,EAAM,GAA2B;CAC7C,OAAO,IAAI,SAAe,MAAY,WAAWC,GAASC,CAAE,CAAC;AACjE;AAaA,SAAgBC,EAAe,GAAqB,GAAY,GAA8B;CAC1F,OAAO,IAAI,SAAY,GAAS,MAAW;EACvC,IAAMC,IAAQ,iBAAiB;GAC3B,IAAMC,IAAY,MAAMC,KAAW,6BAA6BJ,EAAG,GAAG;GAEtE,AADA,EAAM,OAAO,gBACbK,EAAOF,CAAK;EAChB,GAAGH,CAAE;EAEL,EAAQ,MACH,MAAU;GAEP,AADA,aAAaE,CAAK,GAClBH,EAAQO,CAAK;EACjB,IACC,MAAW;GAER,AADA,aAAaJ,CAAK,GAClBG,EAAOE,CAAM;EACjB,CACJ;CACJ,CAAC;AACL"}

package/dist/utils/relative-time.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"relative-time.cjs","names":[],"sources":["../../src/utils/relative-time.ts"],"sourcesContent":["export type RelativeTimeLocale = \"pt-BR\" | \"en\";\n\ninterface Strings {\n    justNow: string;\n    secondsAgo: (n: number) => string;\n    minutesAgo: (n: number) => string;\n    hoursAgo: (n: number) => string;\n    daysAgo: (n: number) => string;\n    weeksAgo: (n: number) => string;\n    monthsAgo: (n: number) => string;\n    yearsAgo: (n: number) => string;\n    inSeconds: (n: number) => string;\n    inMinutes: (n: number) => string;\n    inHours: (n: number) => string;\n    inDays: (n: number) => string;\n    inWeeks: (n: number) => string;\n    inMonths: (n: number) => string;\n    inYears: (n: number) => string;\n}\n\nconst PT_BR: Strings = {\n    justNow: \"agora há pouco\",\n    secondsAgo: (n) => `${n} s atrás`,\n    minutesAgo: (n) => `${n} min atrás`,\n    hoursAgo: (n) => (n === 1 ? \"1 hora atrás\" : `${n} horas atrás`),\n    daysAgo: (n) => (n === 1 ? \"ontem\" : `${n} dias atrás`),\n    weeksAgo: (n) => (n === 1 ? \"semana passada\" : `${n} semanas atrás`),\n    monthsAgo: (n) => (n === 1 ? \"mês passado\" : `${n} meses atrás`),\n    yearsAgo: (n) => (n === 1 ? \"ano passado\" : `${n} anos atrás`),\n    inSeconds: (n) => `em ${n} s`,\n    inMinutes: (n) => `em ${n} min`,\n    inHours: (n) => `em ${n} h`,\n    inDays: (n) => `em ${n} ${n === 1 ? \"dia\" : \"dias\"}`,\n    inWeeks: (n) => `em ${n} ${n === 1 ? \"semana\" : \"semanas\"}`,\n    inMonths: (n) => `em ${n} ${n === 1 ? \"mês\" : \"meses\"}`,\n    inYears: (n) => `em ${n} ${n === 1 ? \"ano\" : \"anos\"}`,\n};\n\nconst EN: Strings = {\n    justNow: \"just now\",\n    secondsAgo: (n) => `${n}s ago`,\n    minutesAgo: (n) => `${n}m ago`,\n    hoursAgo: (n) => `${n}h ago`,\n    daysAgo: (n) => (n === 1 ? \"yesterday\" : `${n} days ago`),\n    weeksAgo: (n) => `${n}w ago`,\n    monthsAgo: (n) => `${n}mo ago`,\n    yearsAgo: (n) => `${n}y ago`,\n    inSeconds: (n) => `in ${n}s`,\n    inMinutes: (n) => `in ${n}m`,\n    inHours: (n) => `in ${n}h`,\n    inDays: (n) => `in ${n}d`,\n    inWeeks: (n) => `in ${n}w`,\n    inMonths: (n) => `in ${n}mo`,\n    inYears: (n) => `in ${n}y`,\n};\n\nconst LOCALES: Record<RelativeTimeLocale, Strings> = { \"pt-BR\": PT_BR, en: EN };\n\nconst SECOND = 1000;\nconst MINUTE = 60 * SECOND;\nconst HOUR = 60 * MINUTE;\nconst DAY = 24 * HOUR;\nconst WEEK = 7 * DAY;\nconst MONTH = 30 * DAY;\nconst YEAR = 365 * DAY;\n\n/**\n * Render a `Date` / ISO string as a relative-time string. Supports past and\n * future, PT-BR (default) and English.\n *\n * @example\n * relativeTime(new Date(Date.now() - 90_000));         // \"1 min atrás\"\n * relativeTime(\"2026-05-17T10:00:00Z\", { locale: \"en\" }); // \"5h ago\"\n */\nexport function relativeTime(\n    input: Date | string | number,\n    options: { locale?: RelativeTimeLocale; now?: Date | number } = {},\n): string {\n    const { locale = \"pt-BR\", now = Date.now() } = options;\n    const strings = LOCALES[locale];\n    const target = input instanceof Date ? input.getTime() : new Date(input).getTime();\n    const nowMs = typeof now === \"number\" ? now : now.getTime();\n    const diff = nowMs - target;\n    const past = diff >= 0;\n    const abs = Math.abs(diff);\n\n    if (abs < 30 * SECOND) return strings.justNow;\n    if (abs < MINUTE) {\n        const n = Math.round(abs / SECOND);\n        return past ? strings.secondsAgo(n) : strings.inSeconds(n);\n    }\n    if (abs < HOUR) {\n        const n = Math.round(abs / MINUTE);\n        return past ? strings.minutesAgo(n) : strings.inMinutes(n);\n    }\n    if (abs < DAY) {\n        const n = Math.round(abs / HOUR);\n        return past ? strings.hoursAgo(n) : strings.inHours(n);\n    }\n    if (abs < WEEK) {\n        const n = Math.round(abs / DAY);\n        return past ? strings.daysAgo(n) : strings.inDays(n);\n    }\n    if (abs < MONTH) {\n        const n = Math.round(abs / WEEK);\n        return past ? strings.weeksAgo(n) : strings.inWeeks(n);\n    }\n    if (abs < YEAR) {\n        const n = Math.round(abs / MONTH);\n        return past ? strings.monthsAgo(n) : strings.inMonths(n);\n    }\n    const n = Math.round(abs / YEAR);\n    return past ? strings.yearsAgo(n) : strings.inYears(n);\n}\n"],"mappings":"AAwDA,IAAM,EAA+C,CAAE,QAAS,CAnC5D,QAAS,iBACT,WAAa,GAAM,GAAG,EAAE,UACxB,WAAa,GAAM,GAAG,EAAE,YACxB,SAAW,GAAO,IAAM,EAAI,eAAiB,GAAG,EAAE,cAClD,QAAU,GAAO,IAAM,EAAI,QAAU,GAAG,EAAE,aAC1C,SAAW,GAAO,IAAM,EAAI,iBAAmB,GAAG,EAAE,gBACpD,UAAY,GAAO,IAAM,EAAI,cAAgB,GAAG,EAAE,cAClD,SAAW,GAAO,IAAM,EAAI,cAAgB,GAAG,EAAE,aACjD,UAAY,GAAM,MAAM,EAAE,IAC1B,UAAY,GAAM,MAAM,EAAE,MAC1B,QAAU,GAAM,MAAM,EAAE,IACxB,OAAS,GAAM,MAAM,EAAE,GAAG,IAAM,EAAI,MAAQ,SAC5C,QAAU,GAAM,MAAM,EAAE,GAAG,IAAM,EAAI,SAAW,YAChD,SAAW,GAAM,MAAM,EAAE,GAAG,IAAM,EAAI,MAAQ,UAC9C,QAAU,GAAM,MAAM,EAAE,GAAG,IAAM,EAAI,MAAQ,QAqBe,EAAO,GAAI,CAjBvE,QAAS,WACT,WAAa,GAAM,GAAG,EAAE,OACxB,WAAa,GAAM,GAAG,EAAE,OACxB,SAAW,GAAM,GAAG,EAAE,OACtB,QAAU,GAAO,IAAM,EAAI,YAAc,GAAG,EAAE,WAC9C,SAAW,GAAM,GAAG,EAAE,OACtB,UAAY,GAAM,GAAG,EAAE,QACvB,SAAW,GAAM,GAAG,EAAE,OACtB,UAAY,GAAM,MAAM,EAAE,GAC1B,UAAY,GAAM,MAAM,EAAE,GAC1B,QAAU,GAAM,MAAM,EAAE,GACxB,OAAS,GAAM,MAAM,EAAE,GACvB,QAAU,GAAM,MAAM,EAAE,GACxB,SAAW,GAAM,MAAM,EAAE,IACzB,QAAU,GAAM,MAAM,EAAE,EAG+C,CAAG,EAExE,EAAS,IACT,EAAS,GAAK,EACd,EAAO,GAAK,EACZ,EAAM,GAAK,EACX,EAAO,EAAI,EACX,EAAQ,GAAK,EACb,EAAO,IAAM,EAUnB,SAAgB,EACZ,EACA,EAAgE,CAAC,EAC3D,CACN,GAAM,CAAE,SAAS,QAAS,MAAM,KAAK,IAAI,GAAM,EACzC,EAAU,EAAQ,GAClB,EAAS,aAAiB,KAAO,EAAM,QAAQ,EAAI,IAAI,KAAK,CAAK,CAAC,CAAC,QAAQ,EAE3E,GADQ,OAAO,GAAQ,SAAW,EAAM,EAAI,QAAQ,GACrC,EACf,EAAO,GAAQ,EACf,EAAM,KAAK,IAAI,CAAI,EAEzB,GAAI,EAAM,GAAK,EAAQ,OAAO,EAAQ,QACtC,GAAI,EAAM,EAAQ,CACd,IAAM,EAAI,KAAK,MAAM,EAAM,CAAM,EACjC,OAAO,EAAO,EAAQ,WAAW,CAAC,EAAI,EAAQ,UAAU,CAAC,CAC7D,CACA,GAAI,EAAM,EAAM,CACZ,IAAM,EAAI,KAAK,MAAM,EAAM,CAAM,EACjC,OAAO,EAAO,EAAQ,WAAW,CAAC,EAAI,EAAQ,UAAU,CAAC,CAC7D,CACA,GAAI,EAAM,EAAK,CACX,IAAM,EAAI,KAAK,MAAM,EAAM,CAAI,EAC/B,OAAO,EAAO,EAAQ,SAAS,CAAC,EAAI,EAAQ,QAAQ,CAAC,CACzD,CACA,GAAI,EAAM,EAAM,CACZ,IAAM,EAAI,KAAK,MAAM,EAAM,CAAG,EAC9B,OAAO,EAAO,EAAQ,QAAQ,CAAC,EAAI,EAAQ,OAAO,CAAC,CACvD,CACA,GAAI,EAAM,EAAO,CACb,IAAM,EAAI,KAAK,MAAM,EAAM,CAAI,EAC/B,OAAO,EAAO,EAAQ,SAAS,CAAC,EAAI,EAAQ,QAAQ,CAAC,CACzD,CACA,GAAI,EAAM,EAAM,CACZ,IAAM,EAAI,KAAK,MAAM,EAAM,CAAK,EAChC,OAAO,EAAO,EAAQ,UAAU,CAAC,EAAI,EAAQ,SAAS,CAAC,CAC3D,CACA,IAAM,EAAI,KAAK,MAAM,EAAM,CAAI,EAC/B,OAAO,EAAO,EAAQ,SAAS,CAAC,EAAI,EAAQ,QAAQ,CAAC,CACzD"}
+{"version":3,"file":"relative-time.cjs","names":["LOCALES","n","SECOND","MINUTE","HOUR","DAY","WEEK","MONTH","YEAR","relativeTime","options","strings","locale","target","input","diff","now","past","abs"],"sources":["../../src/utils/relative-time.ts"],"sourcesContent":["export type RelativeTimeLocale = \"pt-BR\" | \"en\";\n\ninterface Strings {\n    justNow: string;\n    secondsAgo: (n: number) => string;\n    minutesAgo: (n: number) => string;\n    hoursAgo: (n: number) => string;\n    daysAgo: (n: number) => string;\n    weeksAgo: (n: number) => string;\n    monthsAgo: (n: number) => string;\n    yearsAgo: (n: number) => string;\n    inSeconds: (n: number) => string;\n    inMinutes: (n: number) => string;\n    inHours: (n: number) => string;\n    inDays: (n: number) => string;\n    inWeeks: (n: number) => string;\n    inMonths: (n: number) => string;\n    inYears: (n: number) => string;\n}\n\nconst PT_BR: Strings = {\n    justNow: \"agora há pouco\",\n    secondsAgo: (n) => `${n} s atrás`,\n    minutesAgo: (n) => `${n} min atrás`,\n    hoursAgo: (n) => (n === 1 ? \"1 hora atrás\" : `${n} horas atrás`),\n    daysAgo: (n) => (n === 1 ? \"ontem\" : `${n} dias atrás`),\n    weeksAgo: (n) => (n === 1 ? \"semana passada\" : `${n} semanas atrás`),\n    monthsAgo: (n) => (n === 1 ? \"mês passado\" : `${n} meses atrás`),\n    yearsAgo: (n) => (n === 1 ? \"ano passado\" : `${n} anos atrás`),\n    inSeconds: (n) => `em ${n} s`,\n    inMinutes: (n) => `em ${n} min`,\n    inHours: (n) => `em ${n} h`,\n    inDays: (n) => `em ${n} ${n === 1 ? \"dia\" : \"dias\"}`,\n    inWeeks: (n) => `em ${n} ${n === 1 ? \"semana\" : \"semanas\"}`,\n    inMonths: (n) => `em ${n} ${n === 1 ? \"mês\" : \"meses\"}`,\n    inYears: (n) => `em ${n} ${n === 1 ? \"ano\" : \"anos\"}`,\n};\n\nconst EN: Strings = {\n    justNow: \"just now\",\n    secondsAgo: (n) => `${n}s ago`,\n    minutesAgo: (n) => `${n}m ago`,\n    hoursAgo: (n) => `${n}h ago`,\n    daysAgo: (n) => (n === 1 ? \"yesterday\" : `${n} days ago`),\n    weeksAgo: (n) => `${n}w ago`,\n    monthsAgo: (n) => `${n}mo ago`,\n    yearsAgo: (n) => `${n}y ago`,\n    inSeconds: (n) => `in ${n}s`,\n    inMinutes: (n) => `in ${n}m`,\n    inHours: (n) => `in ${n}h`,\n    inDays: (n) => `in ${n}d`,\n    inWeeks: (n) => `in ${n}w`,\n    inMonths: (n) => `in ${n}mo`,\n    inYears: (n) => `in ${n}y`,\n};\n\nconst LOCALES: Record<RelativeTimeLocale, Strings> = { \"pt-BR\": PT_BR, en: EN };\n\nconst SECOND = 1000;\nconst MINUTE = 60 * SECOND;\nconst HOUR = 60 * MINUTE;\nconst DAY = 24 * HOUR;\nconst WEEK = 7 * DAY;\nconst MONTH = 30 * DAY;\nconst YEAR = 365 * DAY;\n\n/**\n * Render a `Date` / ISO string as a relative-time string. Supports past and\n * future, PT-BR (default) and English.\n *\n * @example\n * relativeTime(new Date(Date.now() - 90_000));         // \"1 min atrás\"\n * relativeTime(\"2026-05-17T10:00:00Z\", { locale: \"en\" }); // \"5h ago\"\n */\nexport function relativeTime(\n    input: Date | string | number,\n    options: { locale?: RelativeTimeLocale; now?: Date | number } = {},\n): string {\n    const { locale = \"pt-BR\", now = Date.now() } = options;\n    const strings = LOCALES[locale];\n    const target = input instanceof Date ? input.getTime() : new Date(input).getTime();\n    const nowMs = typeof now === \"number\" ? now : now.getTime();\n    const diff = nowMs - target;\n    const past = diff >= 0;\n    const abs = Math.abs(diff);\n\n    if (abs < 30 * SECOND) return strings.justNow;\n    if (abs < MINUTE) {\n        const n = Math.round(abs / SECOND);\n        return past ? strings.secondsAgo(n) : strings.inSeconds(n);\n    }\n    if (abs < HOUR) {\n        const n = Math.round(abs / MINUTE);\n        return past ? strings.minutesAgo(n) : strings.inMinutes(n);\n    }\n    if (abs < DAY) {\n        const n = Math.round(abs / HOUR);\n        return past ? strings.hoursAgo(n) : strings.inHours(n);\n    }\n    if (abs < WEEK) {\n        const n = Math.round(abs / DAY);\n        return past ? strings.daysAgo(n) : strings.inDays(n);\n    }\n    if (abs < MONTH) {\n        const n = Math.round(abs / WEEK);\n        return past ? strings.weeksAgo(n) : strings.inWeeks(n);\n    }\n    if (abs < YEAR) {\n        const n = Math.round(abs / MONTH);\n        return past ? strings.monthsAgo(n) : strings.inMonths(n);\n    }\n    const n = Math.round(abs / YEAR);\n    return past ? strings.yearsAgo(n) : strings.inYears(n);\n}\n"],"mappings":"AAwDA,IAAMA,EAA+C,CAAE,QAAS,CAnC5D,QAAS,iBACT,WAAa,GAAM,GAAGC,EAAE,UACxB,WAAa,GAAM,GAAGA,EAAE,YACxB,SAAW,GAAOA,IAAM,EAAI,eAAiB,GAAGA,EAAE,cAClD,QAAU,GAAOA,IAAM,EAAI,QAAU,GAAGA,EAAE,aAC1C,SAAW,GAAOA,IAAM,EAAI,iBAAmB,GAAGA,EAAE,gBACpD,UAAY,GAAOA,IAAM,EAAI,cAAgB,GAAGA,EAAE,cAClD,SAAW,GAAOA,IAAM,EAAI,cAAgB,GAAGA,EAAE,aACjD,UAAY,GAAM,MAAMA,EAAE,IAC1B,UAAY,GAAM,MAAMA,EAAE,MAC1B,QAAU,GAAM,MAAMA,EAAE,IACxB,OAAS,GAAM,MAAMA,EAAE,GAAGA,IAAM,EAAI,MAAQ,SAC5C,QAAU,GAAM,MAAMA,EAAE,GAAGA,IAAM,EAAI,SAAW,YAChD,SAAW,GAAM,MAAMA,EAAE,GAAGA,IAAM,EAAI,MAAQ,UAC9C,QAAU,GAAM,MAAMA,EAAE,GAAGA,IAAM,EAAI,MAAQ,QAqBe,EAAO,GAAI,CAjBvE,QAAS,WACT,WAAa,GAAM,GAAGA,EAAE,OACxB,WAAa,GAAM,GAAGA,EAAE,OACxB,SAAW,GAAM,GAAGA,EAAE,OACtB,QAAU,GAAOA,IAAM,EAAI,YAAc,GAAGA,EAAE,WAC9C,SAAW,GAAM,GAAGA,EAAE,OACtB,UAAY,GAAM,GAAGA,EAAE,QACvB,SAAW,GAAM,GAAGA,EAAE,OACtB,UAAY,GAAM,MAAMA,EAAE,GAC1B,UAAY,GAAM,MAAMA,EAAE,GAC1B,QAAU,GAAM,MAAMA,EAAE,GACxB,OAAS,GAAM,MAAMA,EAAE,GACvB,QAAU,GAAM,MAAMA,EAAE,GACxB,SAAW,GAAM,MAAMA,EAAE,IACzB,QAAU,GAAM,MAAMA,EAAE,EAG+C,CAAG,EAExEC,EAAS,IACTC,EAAS,GAAKD,EACdE,EAAO,GAAKD,EACZE,EAAM,GAAKD,EACXE,EAAO,EAAID,EACXE,EAAQ,GAAKF,EACbG,EAAO,IAAMH,EAUnB,SAAgBI,EACZ,EACA,EAAgE,CAAC,EAC3D,CACN,GAAM,CAAE,SAAS,QAAS,MAAM,KAAK,IAAI,GAAMC,EACzCC,EAAUX,EAAQY,GAClBC,EAASC,aAAiB,KAAOA,EAAM,QAAQ,EAAI,IAAI,KAAKA,CAAK,CAAC,CAAC,QAAQ,EAE3EC,GADQ,OAAOC,GAAQ,SAAWA,EAAMA,EAAI,QAAQ,GACrCH,EACfI,EAAOF,GAAQ,EACfG,EAAM,KAAK,IAAIH,CAAI,EAEzB,GAAIG,EAAM,GAAKhB,EAAQ,OAAOS,EAAQ,QACtC,GAAIO,EAAMf,EAAQ,CACd,IAAMF,EAAI,KAAK,MAAMiB,EAAMhB,CAAM,EACjC,OAAOe,EAAON,EAAQ,WAAWV,CAAC,EAAIU,EAAQ,UAAUV,CAAC,CAC7D,CACA,GAAIiB,EAAMd,EAAM,CACZ,IAAMH,EAAI,KAAK,MAAMiB,EAAMf,CAAM,EACjC,OAAOc,EAAON,EAAQ,WAAWV,CAAC,EAAIU,EAAQ,UAAUV,CAAC,CAC7D,CACA,GAAIiB,EAAMb,EAAK,CACX,IAAMJ,EAAI,KAAK,MAAMiB,EAAMd,CAAI,EAC/B,OAAOa,EAAON,EAAQ,SAASV,CAAC,EAAIU,EAAQ,QAAQV,CAAC,CACzD,CACA,GAAIiB,EAAMZ,EAAM,CACZ,IAAML,EAAI,KAAK,MAAMiB,EAAMb,CAAG,EAC9B,OAAOY,EAAON,EAAQ,QAAQV,CAAC,EAAIU,EAAQ,OAAOV,CAAC,CACvD,CACA,GAAIiB,EAAMX,EAAO,CACb,IAAMN,EAAI,KAAK,MAAMiB,EAAMZ,CAAI,EAC/B,OAAOW,EAAON,EAAQ,SAASV,CAAC,EAAIU,EAAQ,QAAQV,CAAC,CACzD,CACA,GAAIiB,EAAMV,EAAM,CACZ,IAAMP,EAAI,KAAK,MAAMiB,EAAMX,CAAK,EAChC,OAAOU,EAAON,EAAQ,UAAUV,CAAC,EAAIU,EAAQ,SAASV,CAAC,CAC3D,CACA,IAAMA,EAAI,KAAK,MAAMiB,EAAMV,CAAI,EAC/B,OAAOS,EAAON,EAAQ,SAASV,CAAC,EAAIU,EAAQ,QAAQV,CAAC,CACzD,C"}