{"version":3,"file":"browser-primitives.cjs","names":["result: string[]"],"sources":["../../src/utils/browser-primitives.ts"],"sourcesContent":["/**\n * Browser-safe replacements for the handful of Node primitives the SDK reaches\n * for: base64url decoding, byte-length measurement, posix path normalization,\n * and a promise-based sleep. All implementations are native (atob/TextEncoder/\n * TextDecoder/string ops) so the browser bundle ships zero polyfill weight.\n *\n * These mirror, exactly, the observable behavior of the Node equivalents they\n * replace (Buffer.from(..,\"base64url\"), Buffer.byteLength, path.posix.*,\n * timers/promises.setTimeout) so the same call sites work under either entry.\n */\n\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder(\"utf-8\");\n\n/** UTF-8 byte length of a string. Replaces Buffer.byteLength(str). */\nexport function byteLength(input: string | Uint8Array): number {\n return typeof input === \"string\"\n ? textEncoder.encode(input).length\n : input.byteLength;\n}\n\n/** Decode a base64url (or base64) segment into bytes. */\nexport function base64UrlToBytes(segment: string): Uint8Array {\n const base64 = segment.replace(/-/g, \"+\").replace(/_/g, \"/\");\n // atob ignores missing padding for base64url; add it back defensively.\n const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, \"=\");\n const binary = atob(padded);\n const bytes = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) {\n bytes[i] = binary.charCodeAt(i);\n }\n return bytes;\n}\n\n/** Decode a base64url segment to a UTF-8 string. Replaces Buffer.from(seg,\"base64url\").toString(\"utf8\"). */\nexport function base64UrlToString(segment: string): string {\n return textDecoder.decode(base64UrlToBytes(segment));\n}\n\n/** Sleep for `ms` milliseconds. Replaces node:timers/promises setTimeout. */\nexport function sleep(ms: number): Promise {\n return new Promise((resolve) => globalThis.setTimeout(resolve, ms));\n}\n\n/**\n * Sleep for `ms`, rejecting early if the signal aborts. Isomorphic replacement\n * for `node:timers/promises` setTimeout(ms, value, { signal }).\n */\nexport function sleepWithSignal(\n ms: number,\n signal?: AbortSignal,\n): Promise {\n return new Promise((resolve, reject) => {\n if (signal?.aborted) {\n reject(signal.reason ?? new DOMException(\"Aborted\", \"AbortError\"));\n return;\n }\n const timer = globalThis.setTimeout(() => {\n signal?.removeEventListener(\"abort\", onAbort);\n resolve();\n }, ms);\n const onAbort = () => {\n globalThis.clearTimeout(timer);\n reject(signal!.reason ?? new DOMException(\"Aborted\", \"AbortError\"));\n };\n signal?.addEventListener(\"abort\", onAbort, { once: true });\n });\n}\n\n/**\n * Inlined POSIX path operations — only the four the SDK uses (isAbsolute,\n * normalize, join, relative). Pure string algorithms, no runtime dependency.\n */\nfunction normalizeArray(parts: string[], allowAboveRoot: boolean): string[] {\n const result: string[] = [];\n for (const part of parts) {\n if (part === \"\" || part === \".\") continue;\n if (part === \"..\") {\n if (result.length && result[result.length - 1] !== \"..\") {\n result.pop();\n } else if (allowAboveRoot) {\n result.push(\"..\");\n }\n } else {\n result.push(part);\n }\n }\n return result;\n}\n\nexport const posix = {\n isAbsolute(p: string): boolean {\n return p.length > 0 && p[0] === \"/\";\n },\n\n normalize(p: string): string {\n const isAbs = posix.isAbsolute(p);\n const trailingSlash = p.length > 1 && p[p.length - 1] === \"/\";\n let normalized = normalizeArray(p.split(\"/\"), !isAbs).join(\"/\");\n if (!normalized && !isAbs) normalized = \".\";\n if (normalized && trailingSlash) normalized += \"/\";\n return (isAbs ? \"/\" : \"\") + normalized;\n },\n\n join(...segments: string[]): string {\n const joined = segments.filter((s) => s.length > 0).join(\"/\");\n return joined === \"\" ? \".\" : posix.normalize(joined);\n },\n\n relative(from: string, to: string): string {\n from = posix.normalize(from);\n to = posix.normalize(to);\n if (from === to) return \"\";\n\n const fromParts = from.split(\"/\").filter(Boolean);\n const toParts = to.split(\"/\").filter(Boolean);\n\n let i = 0;\n const min = Math.min(fromParts.length, toParts.length);\n while (i < min && fromParts[i] === toParts[i]) i++;\n\n const up = fromParts.slice(i).map(() => \"..\");\n return [...up, ...toParts.slice(i)].join(\"/\");\n },\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAM,cAAc,IAAI,aAAa;AACrC,MAAM,cAAc,IAAI,YAAY,QAAQ;;;;;AAoC5C,SAAgB,gBACd,IACA,QACe;AACf,QAAO,IAAI,SAAS,SAAS,WAAW;AACtC,MAAI,QAAQ,SAAS;AACnB,UAAO,OAAO,UAAU,IAAI,aAAa,WAAW,aAAa,CAAC;AAClE;;EAEF,MAAM,QAAQ,WAAW,iBAAiB;AACxC,WAAQ,oBAAoB,SAAS,QAAQ;AAC7C,YAAS;KACR,GAAG;EACN,MAAM,gBAAgB;AACpB,cAAW,aAAa,MAAM;AAC9B,UAAO,OAAQ,UAAU,IAAI,aAAa,WAAW,aAAa,CAAC;;AAErE,UAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,MAAM,CAAC;GAC1D;;;;;;AAOJ,SAAS,eAAe,OAAiB,gBAAmC;CAC1E,MAAMA,SAAmB,EAAE;AAC3B,MAAK,MAAM,QAAQ,OAAO;AACxB,MAAI,SAAS,MAAM,SAAS,IAAK;AACjC,MAAI,SAAS,MACX;OAAI,OAAO,UAAU,OAAO,OAAO,SAAS,OAAO,KACjD,QAAO,KAAK;YACH,eACT,QAAO,KAAK,KAAK;QAGnB,QAAO,KAAK,KAAK;;AAGrB,QAAO;;AAGT,MAAa,QAAQ;CACnB,WAAW,GAAoB;AAC7B,SAAO,EAAE,SAAS,KAAK,EAAE,OAAO;;CAGlC,UAAU,GAAmB;EAC3B,MAAM,QAAQ,MAAM,WAAW,EAAE;EACjC,MAAM,gBAAgB,EAAE,SAAS,KAAK,EAAE,EAAE,SAAS,OAAO;EAC1D,IAAI,aAAa,eAAe,EAAE,MAAM,IAAI,EAAE,CAAC,MAAM,CAAC,KAAK,IAAI;AAC/D,MAAI,CAAC,cAAc,CAAC,MAAO,cAAa;AACxC,MAAI,cAAc,cAAe,eAAc;AAC/C,UAAQ,QAAQ,MAAM,MAAM;;CAG9B,KAAK,GAAG,UAA4B;EAClC,MAAM,SAAS,SAAS,QAAQ,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,IAAI;AAC7D,SAAO,WAAW,KAAK,MAAM,MAAM,UAAU,OAAO;;CAGtD,SAAS,MAAc,IAAoB;AACzC,SAAO,MAAM,UAAU,KAAK;AAC5B,OAAK,MAAM,UAAU,GAAG;AACxB,MAAI,SAAS,GAAI,QAAO;EAExB,MAAM,YAAY,KAAK,MAAM,IAAI,CAAC,OAAO,QAAQ;EACjD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,OAAO,QAAQ;EAE7C,IAAI,IAAI;EACR,MAAM,MAAM,KAAK,IAAI,UAAU,QAAQ,QAAQ,OAAO;AACtD,SAAO,IAAI,OAAO,UAAU,OAAO,QAAQ,GAAI;AAG/C,SAAO,CAAC,GADG,UAAU,MAAM,EAAE,CAAC,UAAU,KAAK,EAC9B,GAAG,QAAQ,MAAM,EAAE,CAAC,CAAC,KAAK,IAAI;;CAEhD"}