@hexclave/shared 1.0.40 → 1.0.42

package/dist/esm/utils/arrays.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrays.js","names":[],"sources":["../../../src/utils/arrays.tsx"],"sourcesContent":["import { remainder } from \"./math\";\n\nexport function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number] {\n  return arr.includes(item);\n}\nimport.meta.vitest?.test(\"typedIncludes\", ({ expect }) => {\n  const arr = [1, 2, 3] as const;\n  expect(typedIncludes(arr, 1)).toBe(true);\n  expect(typedIncludes(arr, 4)).toBe(false);\n  expect(typedIncludes(arr, \"1\")).toBe(false);\n\n  const strArr = [\"a\", \"b\", \"c\"] as const;\n  expect(typedIncludes(strArr, \"a\")).toBe(true);\n  expect(typedIncludes(strArr, \"d\")).toBe(false);\n});\n\nexport function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][] {\n  return arr.map((item, index) => [index, item]);\n}\nimport.meta.vitest?.test(\"enumerate\", ({ expect }) => {\n  expect(enumerate([])).toEqual([]);\n  expect(enumerate([1, 2, 3])).toEqual([[0, 1], [1, 2], [2, 3]]);\n  expect(enumerate([\"a\", \"b\", \"c\"])).toEqual([[0, \"a\"], [1, \"b\"], [2, \"c\"]]);\n});\n\nexport function isShallowEqual(a: readonly any[], b: readonly any[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\nimport.meta.vitest?.test(\"isShallowEqual\", ({ expect }) => {\n  expect(isShallowEqual([], [])).toBe(true);\n  expect(isShallowEqual([1, 2, 3], [1, 2, 3])).toBe(true);\n  expect(isShallowEqual([1, 2, 3], [1, 2, 4])).toBe(false);\n  expect(isShallowEqual([1, 2, 3], [1, 2])).toBe(false);\n  expect(isShallowEqual([1, 2], [1, 2, 3])).toBe(false);\n  // Test with objects (reference equality)\n  const obj1 = { a: 1 };\n  const obj2 = { a: 1 };\n  expect(isShallowEqual([obj1], [obj1])).toBe(true);\n  expect(isShallowEqual([obj1], [obj2])).toBe(false);\n});\n\n/**\n * Ponyfill for ES2023's findLastIndex.\n */\nexport function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (predicate(arr[i])) return i;\n  }\n  return -1;\n}\nimport.meta.vitest?.test(\"findLastIndex\", ({ expect }) => {\n  expect(findLastIndex([], () => true)).toBe(-1);\n  expect(findLastIndex([1, 2, 3, 4, 5], x => x % 2 === 0)).toBe(3); // 4 is at index 3\n  expect(findLastIndex([1, 2, 3, 4, 5], x => x > 10)).toBe(-1);\n  expect(findLastIndex([1, 2, 3, 2, 1], x => x === 2)).toBe(3);\n  expect(findLastIndex([1, 2, 3], x => x === 1)).toBe(0);\n});\n\nexport function groupBy<T extends any, K>(\n  arr: Iterable<T>,\n  key: (item: T) => K,\n): Map<K, T[]> {\n  const result = new Map<K, T[]>;\n  for (const item of arr) {\n    const k = key(item);\n    if (result.get(k) === undefined) result.set(k, []);\n    result.get(k)!.push(item);\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"groupBy\", ({ expect }) => {\n  expect(groupBy([], (x) => x)).toEqual(new Map());\n\n  const numbers = [1, 2, 3, 4, 5, 6];\n  const grouped = groupBy(numbers, (n) => n % 2 === 0 ? \"even\" : \"odd\");\n  expect(grouped.get(\"even\")).toEqual([2, 4, 6]);\n  expect(grouped.get(\"odd\")).toEqual([1, 3, 5]);\n\n  // Check the actual lengths of the words to ensure our test is correct\n  const words = [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\"];\n\n  const byLength = groupBy(words, (w) => w.length);\n  // Adjust expectations based on actual word lengths\n  expect(byLength.get(5)).toEqual([\"apple\"]);\n  expect(byLength.get(6)).toEqual([\"banana\", \"cherry\"]);\n  expect(byLength.get(4)).toEqual([\"date\"]);\n  expect(byLength.get(10)).toEqual([\"elderberry\"]);\n});\n\nexport function range(endExclusive: number): number[];\nexport function range(startInclusive: number, endExclusive: number): number[];\nexport function range(startInclusive: number, endExclusive: number, step: number): number[];\nexport function range(startInclusive: number, endExclusive?: number, step?: number): number[] {\n  if (endExclusive === undefined) {\n    endExclusive = startInclusive;\n    startInclusive = 0;\n  }\n  if (step === undefined) step = 1;\n\n  const result = [];\n  for (let i = startInclusive; step > 0 ? (i < endExclusive) : (i > endExclusive); i += step) {\n    result.push(i);\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"range\", ({ expect }) => {\n  expect(range(5)).toEqual([0, 1, 2, 3, 4]);\n  expect(range(2, 5)).toEqual([2, 3, 4]);\n  expect(range(1, 10, 2)).toEqual([1, 3, 5, 7, 9]);\n  expect(range(5, 0, -1)).toEqual([5, 4, 3, 2, 1]);\n  expect(range(0, 0)).toEqual([]);\n  expect(range(0, 10, 3)).toEqual([0, 3, 6, 9]);\n});\n\n\nexport function rotateLeft(arr: readonly any[], n: number): any[] {\n  if (arr.length === 0) return [];\n  const index = remainder(n, arr.length);\n  return [...arr.slice(index), ...arr.slice(0, index)];\n}\nimport.meta.vitest?.test(\"rotateLeft\", ({ expect }) => {\n  expect(rotateLeft([], 1)).toEqual([]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 1)).toEqual([2, 3, 4, 5, 1]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 3)).toEqual([4, 5, 1, 2, 3]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 6)).toEqual([2, 3, 4, 5, 1]);\n});\n\nexport function rotateRight(arr: readonly any[], n: number): any[] {\n  return rotateLeft(arr, -n);\n}\nimport.meta.vitest?.test(\"rotateRight\", ({ expect }) => {\n  expect(rotateRight([], 1)).toEqual([]);\n  expect(rotateRight([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateRight([1, 2, 3, 4, 5], 1)).toEqual([5, 1, 2, 3, 4]);\n  expect(rotateRight([1, 2, 3, 4, 5], 3)).toEqual([3, 4, 5, 1, 2]);\n  expect(rotateRight([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateRight([1, 2, 3, 4, 5], 6)).toEqual([5, 1, 2, 3, 4]);\n});\n\n\nexport function shuffle<T>(arr: readonly T[]): T[] {\n  const result = [...arr];\n  for (let i = result.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [result[i], result[j]] = [result[j], result[i]];\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"shuffle\", ({ expect }) => {\n  // Test empty array\n  expect(shuffle([])).toEqual([]);\n\n  // Test single element array\n  expect(shuffle([1])).toEqual([1]);\n\n  // Test that shuffle returns a new array\n  const original = [1, 2, 3, 4, 5];\n  const shuffled = shuffle(original);\n  expect(shuffled).not.toBe(original);\n\n  // Test that all elements are preserved\n  expect(shuffled.sort((a, b) => a - b)).toEqual(original);\n\n  // Test with a larger array to ensure randomness\n  // This is a probabilistic test, but it's very unlikely to fail\n  const large = Array.from({ length: 100 }, (_, i) => i);\n  const shuffledLarge = shuffle(large);\n  expect(shuffledLarge).not.toEqual(large);\n  expect(shuffledLarge.sort((a, b) => a - b)).toEqual(large);\n});\n\n\nexport function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][] {\n  return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2] as [T, U]));\n}\nimport.meta.vitest?.test(\"outerProduct\", ({ expect }) => {\n  expect(outerProduct([], [])).toEqual([]);\n  expect(outerProduct([1], [])).toEqual([]);\n  expect(outerProduct([], [1])).toEqual([]);\n  expect(outerProduct([1], [2])).toEqual([[1, 2]]);\n  expect(outerProduct([1, 2], [3, 4])).toEqual([[1, 3], [1, 4], [2, 3], [2, 4]]);\n  expect(outerProduct([\"a\", \"b\"], [1, 2])).toEqual([[\"a\", 1], [\"a\", 2], [\"b\", 1], [\"b\", 2]]);\n});\n\nexport function unique<T>(arr: readonly T[]): T[] {\n  return [...new Set(arr)];\n}\nimport.meta.vitest?.test(\"unique\", ({ expect }) => {\n  expect(unique([])).toEqual([]);\n  expect(unique([1, 2, 3])).toEqual([1, 2, 3]);\n  expect(unique([1, 2, 2, 3, 1, 3])).toEqual([1, 2, 3]);\n  // Test with objects (reference equality)\n  const obj = { a: 1 };\n  expect(unique([obj, obj])).toEqual([obj]);\n  // Test with different types\n  expect(unique([1, \"1\", true, 1, \"1\", true])).toEqual([1, \"1\", true]);\n});\n\n\nexport function getChunks<T>(arr: readonly T[], size: number): T[][] {\n  const result: T[][] = [];\n  if (size <= 0) return result;\n  for (let i = 0; i < arr.length; i += size) {\n    result.push(arr.slice(i, i + size));\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"getChunks\", ({ expect }) => {\n  expect(getChunks([], 2)).toEqual([]);\n  expect(getChunks([1], 2)).toEqual([[1]]);\n  expect(getChunks([1, 2], 2)).toEqual([[1, 2]]);\n  expect(getChunks([1, 2, 3], 2)).toEqual([[1, 2], [3]]);\n  expect(getChunks([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);\n  expect(getChunks([1, 2, 3, 4], 3)).toEqual([[1, 2, 3], [4]]);\n  expect(getChunks([1, 2, 3], 0)).toEqual([]);\n  expect(getChunks([1, 2, 3], -1)).toEqual([]);\n});\n\nexport function isStringArray(arr: unknown): arr is string[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"string\");\n}\nexport function isNumberArray(arr: unknown): arr is number[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"number\");\n}\nexport function isBooleanArray(arr: unknown): arr is boolean[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"boolean\");\n}\nexport function isObjectArray(arr: unknown): arr is object[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"object\" && item !== null);\n}\nimport.meta.vitest?.test(\"is<Type>Array\", ({ expect }) => {\n  expect(isStringArray([])).toBe(true);\n  expect(isNumberArray([1, 2, 3])).toBe(true);\n  expect(isBooleanArray([true, false, true])).toBe(true);\n  expect(isObjectArray([{ a: 1 }, { b: 2 }, { c: 3 }])).toBe(true);\n  expect(isStringArray([1, 2, 3])).toBe(false);\n  expect(isNumberArray([\"a\", \"b\", \"c\"])).toBe(false);\n  expect(isBooleanArray([1, 2, 3])).toBe(false);\n  expect(isObjectArray([1, 2, 3])).toBe(false);\n  expect(isObjectArray([{ a: 1 }, null, { b: 2 }])).toBe(false);\n  expect(isObjectArray([{ a: 1 }, undefined, { b: 2 }])).toBe(false);\n});\n"],"mappings":"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"}
+{"version":3,"file":"arrays.js","names":[],"sources":["../../../src/utils/arrays.tsx"],"sourcesContent":["import { remainder } from \"./math\";\n\nexport function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number] {\n  return arr.includes(item);\n}\nimport.meta.vitest?.test(\"typedIncludes\", ({ expect }) => {\n  const arr = [1, 2, 3] as const;\n  expect(typedIncludes(arr, 1)).toBe(true);\n  expect(typedIncludes(arr, 4)).toBe(false);\n  expect(typedIncludes(arr, \"1\")).toBe(false);\n\n  const strArr = [\"a\", \"b\", \"c\"] as const;\n  expect(typedIncludes(strArr, \"a\")).toBe(true);\n  expect(typedIncludes(strArr, \"d\")).toBe(false);\n});\n\nexport function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][] {\n  return arr.map((item, index) => [index, item]);\n}\nimport.meta.vitest?.test(\"enumerate\", ({ expect }) => {\n  expect(enumerate([])).toEqual([]);\n  expect(enumerate([1, 2, 3])).toEqual([[0, 1], [1, 2], [2, 3]]);\n  expect(enumerate([\"a\", \"b\", \"c\"])).toEqual([[0, \"a\"], [1, \"b\"], [2, \"c\"]]);\n});\n\nexport function isShallowEqual(a: readonly any[], b: readonly any[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\nimport.meta.vitest?.test(\"isShallowEqual\", ({ expect }) => {\n  expect(isShallowEqual([], [])).toBe(true);\n  expect(isShallowEqual([1, 2, 3], [1, 2, 3])).toBe(true);\n  expect(isShallowEqual([1, 2, 3], [1, 2, 4])).toBe(false);\n  expect(isShallowEqual([1, 2, 3], [1, 2])).toBe(false);\n  expect(isShallowEqual([1, 2], [1, 2, 3])).toBe(false);\n  // Test with objects (reference equality)\n  const obj1 = { a: 1 };\n  const obj2 = { a: 1 };\n  expect(isShallowEqual([obj1], [obj1])).toBe(true);\n  expect(isShallowEqual([obj1], [obj2])).toBe(false);\n});\n\n/**\n * Ponyfill for ES2023's findLastIndex.\n */\nexport function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (predicate(arr[i])) return i;\n  }\n  return -1;\n}\nimport.meta.vitest?.test(\"findLastIndex\", ({ expect }) => {\n  expect(findLastIndex([], () => true)).toBe(-1);\n  expect(findLastIndex([1, 2, 3, 4, 5], x => x % 2 === 0)).toBe(3); // 4 is at index 3\n  expect(findLastIndex([1, 2, 3, 4, 5], x => x > 10)).toBe(-1);\n  expect(findLastIndex([1, 2, 3, 2, 1], x => x === 2)).toBe(3);\n  expect(findLastIndex([1, 2, 3], x => x === 1)).toBe(0);\n});\n\nexport function groupBy<T extends any, K>(\n  arr: Iterable<T>,\n  key: (item: T) => K,\n): Map<K, T[]> {\n  const result = new Map<K, T[]>;\n  for (const item of arr) {\n    const k = key(item);\n    if (result.get(k) === undefined) result.set(k, []);\n    result.get(k)!.push(item);\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"groupBy\", ({ expect }) => {\n  expect(groupBy([], (x) => x)).toEqual(new Map());\n\n  const numbers = [1, 2, 3, 4, 5, 6];\n  const grouped = groupBy(numbers, (n) => n % 2 === 0 ? \"even\" : \"odd\");\n  expect(grouped.get(\"even\")).toEqual([2, 4, 6]);\n  expect(grouped.get(\"odd\")).toEqual([1, 3, 5]);\n\n  // Check the actual lengths of the words to ensure our test is correct\n  const words = [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\"];\n\n  const byLength = groupBy(words, (w) => w.length);\n  // Adjust expectations based on actual word lengths\n  expect(byLength.get(5)).toEqual([\"apple\"]);\n  expect(byLength.get(6)).toEqual([\"banana\", \"cherry\"]);\n  expect(byLength.get(4)).toEqual([\"date\"]);\n  expect(byLength.get(10)).toEqual([\"elderberry\"]);\n});\n\nexport function range(endExclusive: number): number[];\nexport function range(startInclusive: number, endExclusive: number): number[];\nexport function range(startInclusive: number, endExclusive: number, step: number): number[];\nexport function range(startInclusive: number, endExclusive?: number, step?: number): number[] {\n  if (endExclusive === undefined) {\n    endExclusive = startInclusive;\n    startInclusive = 0;\n  }\n  if (step === undefined) step = 1;\n\n  const result = [];\n  for (let i = startInclusive; step > 0 ? (i < endExclusive) : (i > endExclusive); i += step) {\n    result.push(i);\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"range\", ({ expect }) => {\n  expect(range(5)).toEqual([0, 1, 2, 3, 4]);\n  expect(range(2, 5)).toEqual([2, 3, 4]);\n  expect(range(1, 10, 2)).toEqual([1, 3, 5, 7, 9]);\n  expect(range(5, 0, -1)).toEqual([5, 4, 3, 2, 1]);\n  expect(range(0, 0)).toEqual([]);\n  expect(range(0, 10, 3)).toEqual([0, 3, 6, 9]);\n});\n\n\nexport function rotateLeft(arr: readonly any[], n: number): any[] {\n  if (arr.length === 0) return [];\n  const index = remainder(n, arr.length);\n  return [...arr.slice(index), ...arr.slice(0, index)];\n}\nimport.meta.vitest?.test(\"rotateLeft\", ({ expect }) => {\n  expect(rotateLeft([], 1)).toEqual([]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 1)).toEqual([2, 3, 4, 5, 1]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 3)).toEqual([4, 5, 1, 2, 3]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateLeft([1, 2, 3, 4, 5], 6)).toEqual([2, 3, 4, 5, 1]);\n});\n\nexport function rotateRight(arr: readonly any[], n: number): any[] {\n  return rotateLeft(arr, -n);\n}\nimport.meta.vitest?.test(\"rotateRight\", ({ expect }) => {\n  expect(rotateRight([], 1)).toEqual([]);\n  expect(rotateRight([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateRight([1, 2, 3, 4, 5], 1)).toEqual([5, 1, 2, 3, 4]);\n  expect(rotateRight([1, 2, 3, 4, 5], 3)).toEqual([3, 4, 5, 1, 2]);\n  expect(rotateRight([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);\n  expect(rotateRight([1, 2, 3, 4, 5], 6)).toEqual([5, 1, 2, 3, 4]);\n});\n\n\nexport function shuffle<T>(arr: readonly T[]): T[] {\n  const result = [...arr];\n  for (let i = result.length - 1; i > 0; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [result[i], result[j]] = [result[j], result[i]];\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"shuffle\", ({ expect }) => {\n  // Test empty array\n  expect(shuffle([])).toEqual([]);\n\n  // Test single element array\n  expect(shuffle([1])).toEqual([1]);\n\n  // Test that shuffle returns a new array\n  const original = [1, 2, 3, 4, 5];\n  const shuffled = shuffle(original);\n  expect(shuffled).not.toBe(original);\n\n  // Test that all elements are preserved\n  expect(shuffled.sort((a, b) => a - b)).toEqual(original);\n\n  // Test with a larger array to ensure randomness\n  // This is a probabilistic test, but it's very unlikely to fail\n  const large = Array.from({ length: 100 }, (_, i) => i);\n  const shuffledLarge = shuffle(large);\n  expect(shuffledLarge).not.toEqual(large);\n  expect(shuffledLarge.sort((a, b) => a - b)).toEqual(large);\n});\n\n\nexport function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][] {\n  return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2] as [T, U]));\n}\nimport.meta.vitest?.test(\"outerProduct\", ({ expect }) => {\n  expect(outerProduct([], [])).toEqual([]);\n  expect(outerProduct([1], [])).toEqual([]);\n  expect(outerProduct([], [1])).toEqual([]);\n  expect(outerProduct([1], [2])).toEqual([[1, 2]]);\n  expect(outerProduct([1, 2], [3, 4])).toEqual([[1, 3], [1, 4], [2, 3], [2, 4]]);\n  expect(outerProduct([\"a\", \"b\"], [1, 2])).toEqual([[\"a\", 1], [\"a\", 2], [\"b\", 1], [\"b\", 2]]);\n});\n\nexport function unique<T>(arr: readonly T[]): T[] {\n  return [...new Set(arr)];\n}\nimport.meta.vitest?.test(\"unique\", ({ expect }) => {\n  expect(unique([])).toEqual([]);\n  expect(unique([1, 2, 3])).toEqual([1, 2, 3]);\n  expect(unique([1, 2, 2, 3, 1, 3])).toEqual([1, 2, 3]);\n  // Test with objects (reference equality)\n  const obj = { a: 1 };\n  expect(unique([obj, obj])).toEqual([obj]);\n  // Test with different types\n  expect(unique([1, \"1\", true, 1, \"1\", true])).toEqual([1, \"1\", true]);\n});\n\n\nexport function getChunks<T>(arr: readonly T[], size: number): T[][] {\n  const result: T[][] = [];\n  if (size <= 0) return result;\n  for (let i = 0; i < arr.length; i += size) {\n    result.push(arr.slice(i, i + size));\n  }\n  return result;\n}\nimport.meta.vitest?.test(\"getChunks\", ({ expect }) => {\n  expect(getChunks([], 2)).toEqual([]);\n  expect(getChunks([1], 2)).toEqual([[1]]);\n  expect(getChunks([1, 2], 2)).toEqual([[1, 2]]);\n  expect(getChunks([1, 2, 3], 2)).toEqual([[1, 2], [3]]);\n  expect(getChunks([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);\n  expect(getChunks([1, 2, 3, 4], 3)).toEqual([[1, 2, 3], [4]]);\n  expect(getChunks([1, 2, 3], 0)).toEqual([]);\n  expect(getChunks([1, 2, 3], -1)).toEqual([]);\n});\n\nexport function isStringArray(arr: unknown): arr is string[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"string\");\n}\nexport function isNumberArray(arr: unknown): arr is number[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"number\");\n}\nexport function isBooleanArray(arr: unknown): arr is boolean[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"boolean\");\n}\nexport function isObjectArray(arr: unknown): arr is object[] {\n  return Array.isArray(arr) && arr.every((item) => typeof item === \"object\" && item !== null);\n}\nimport.meta.vitest?.test(\"is<Type>Array\", ({ expect }) => {\n  expect(isStringArray([])).toBe(true);\n  expect(isNumberArray([1, 2, 3])).toBe(true);\n  expect(isBooleanArray([true, false, true])).toBe(true);\n  expect(isObjectArray([{ a: 1 }, { b: 2 }, { c: 3 }])).toBe(true);\n  expect(isStringArray([1, 2, 3])).toBe(false);\n  expect(isNumberArray([\"a\", \"b\", \"c\"])).toBe(false);\n  expect(isBooleanArray([1, 2, 3])).toBe(false);\n  expect(isObjectArray([1, 2, 3])).toBe(false);\n  expect(isObjectArray([{ a: 1 }, null, { b: 2 }])).toBe(false);\n  expect(isObjectArray([{ a: 1 }, undefined, { b: 2 }])).toBe(false);\n});\n"],"mappings":"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"}

package/dist/esm/utils/auth-methods.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-methods.d.ts","names":[],"sources":["../../../src/utils/auth-methods.ts"],"mappings":";cAAa,sBAAA;AAAA,KAOD,gBAAA,UAA0B,sBAAA"}
+{"version":3,"file":"auth-methods.d.ts","names":[],"sources":["../../../src/utils/auth-methods.ts"],"mappings":";cAAa,sBAAA;AAAA,KAOD,gBAAA,UAA0B,sBAAsB"}

package/dist/esm/utils/auth-methods.js

@@ -5,7 +5,7 @@ const signUpAuthMethodValues = [
 	"oauth",
 	"passkey"
 ];
-
 //#endregion
 export { signUpAuthMethodValues };
+
 //# sourceMappingURL=auth-methods.js.map

package/dist/esm/utils/auth-methods.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth-methods.js","names":[],"sources":["../../../src/utils/auth-methods.ts"],"sourcesContent":["export const signUpAuthMethodValues = [\n  \"password\",\n  \"otp\",\n  \"oauth\",\n  \"passkey\",\n] as const;\n\nexport type SignUpAuthMethod = typeof signUpAuthMethodValues[number];\n"],"mappings":";AAAA,MAAa,yBAAyB;CACpC;CACA;CACA;CACA;CACD"}
+{"version":3,"file":"auth-methods.js","names":[],"sources":["../../../src/utils/auth-methods.ts"],"sourcesContent":["export const signUpAuthMethodValues = [\n  \"password\",\n  \"otp\",\n  \"oauth\",\n  \"passkey\",\n] as const;\n\nexport type SignUpAuthMethod = typeof signUpAuthMethodValues[number];\n"],"mappings":";AAAA,MAAa,yBAAyB;CACpC;CACA;CACA;CACA;AACF"}

package/dist/esm/utils/base64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base64.d.ts","names":[],"sources":["../../../src/utils/base64.tsx"],"mappings":";iBAAgB,YAAA,CAAa,IAAA,EAAM,IAAA,GAAO,OAAA;AAAA,iBAS1B,mBAAA,CAAoB,MAAA"}
+{"version":3,"file":"base64.d.ts","names":[],"sources":["../../../src/utils/base64.tsx"],"mappings":";iBAAgB,YAAA,CAAa,IAAA,EAAM,IAAA,GAAO,OAAO;AAAA,iBASjC,mBAAA,CAAoB,MAAc"}

package/dist/esm/utils/base64.js

@@ -10,16 +10,7 @@ function fileToBase64(file) {
 function validateBase64Image(base64) {
 	return /^data:image\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/.test(base64);
 }
-(void 0)?.test("validateBase64Image", ({ expect }) => {
-	expect(validateBase64Image("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==")).toBe(true);
-	expect(validateBase64Image("data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBA")).toBe(true);
-	expect(validateBase64Image("ABC123")).toBe(true);
-	expect(validateBase64Image("data:text/plain;base64,SGVsbG8gV29ybGQ=")).toBe(false);
-	expect(validateBase64Image("data:image/png;base64,invalid!base64")).toBe(false);
-	expect(validateBase64Image("not a base64 string")).toBe(false);
-	expect(validateBase64Image("")).toBe(false);
-});
-
 //#endregion
 export { fileToBase64, validateBase64Image };
+
 //# sourceMappingURL=base64.js.map

package/dist/esm/utils/base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"base64.js","names":[],"sources":["../../../src/utils/base64.tsx"],"sourcesContent":["export function fileToBase64(file: File): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.readAsDataURL(file);\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = error => reject(error);\n  });\n}\n\nexport function validateBase64Image(base64: string): boolean {\n  const base64ImageRegex = /^data:image\\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/;\n  return base64ImageRegex.test(base64);\n}\nimport.meta.vitest?.test(\"validateBase64Image\", ({ expect }) => {\n  // Valid base64 image strings\n  expect(validateBase64Image(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==\")).toBe(true);\n  expect(validateBase64Image(\"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBA\")).toBe(true);\n  expect(validateBase64Image(\"ABC123\")).toBe(true);\n  // Invalid base64 image strings\n  expect(validateBase64Image(\"data:text/plain;base64,SGVsbG8gV29ybGQ=\")).toBe(false);\n  expect(validateBase64Image(\"data:image/png;base64,invalid!base64\")).toBe(false);\n  expect(validateBase64Image(\"not a base64 string\")).toBe(false);\n  expect(validateBase64Image(\"\")).toBe(false);\n});\n"],"mappings":";AAAA,SAAgB,aAAa,MAA6B;AACxD,QAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,SAAS,IAAI,YAAY;AAC/B,SAAO,cAAc,KAAK;AAC1B,SAAO,eAAe,QAAQ,OAAO,OAAiB;AACtD,SAAO,WAAU,UAAS,OAAO,MAAM;GACvC;;AAGJ,SAAgB,oBAAoB,QAAyB;AAE3D,QADyB,+FACD,KAAK,OAAO;;CAEtC,SAAW,KAAC,wBAAc,EAAA,aAAyB;AAEjD,QAAO,oBAAoB,yHAAyH,CAAC,CAAC,KAAK,KAAK;AAChK,QAAO,oBAAoB,mRAAmR,CAAC,CAAC,KAAK,KAAK;AAC1T,QAAO,oBAAoB,SAAS,CAAC,CAAC,KAAK,KAAK;AAEhD,QAAO,oBAAoB,0CAA0C,CAAC,CAAC,KAAK,MAAM;AAClF,QAAO,oBAAoB,uCAAuC,CAAC,CAAC,KAAK,MAAM;AAC/E,QAAO,oBAAoB,sBAAsB,CAAC,CAAC,KAAK,MAAM;AAC9D,QAAO,oBAAoB,GAAG,CAAC,CAAC,KAAK,MAAM;EAC3C"}
+{"version":3,"file":"base64.js","names":[],"sources":["../../../src/utils/base64.tsx"],"sourcesContent":["export function fileToBase64(file: File): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.readAsDataURL(file);\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = error => reject(error);\n  });\n}\n\nexport function validateBase64Image(base64: string): boolean {\n  const base64ImageRegex = /^data:image\\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/;\n  return base64ImageRegex.test(base64);\n}\nimport.meta.vitest?.test(\"validateBase64Image\", ({ expect }) => {\n  // Valid base64 image strings\n  expect(validateBase64Image(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==\")).toBe(true);\n  expect(validateBase64Image(\"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBA\")).toBe(true);\n  expect(validateBase64Image(\"ABC123\")).toBe(true);\n  // Invalid base64 image strings\n  expect(validateBase64Image(\"data:text/plain;base64,SGVsbG8gV29ybGQ=\")).toBe(false);\n  expect(validateBase64Image(\"data:image/png;base64,invalid!base64\")).toBe(false);\n  expect(validateBase64Image(\"not a base64 string\")).toBe(false);\n  expect(validateBase64Image(\"\")).toBe(false);\n});\n"],"mappings":";AAAA,SAAgB,aAAa,MAA6B;CACxD,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,SAAS,IAAI,WAAW;EAC9B,OAAO,cAAc,IAAI;EACzB,OAAO,eAAe,QAAQ,OAAO,MAAgB;EACrD,OAAO,WAAU,UAAS,OAAO,KAAK;CACxC,CAAC;AACH;AAEA,SAAgB,oBAAoB,QAAyB;CAE3D,OAAO,+FAAiB,KAAK,MAAM;AACrC"}

package/dist/esm/utils/booleans.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"booleans.d.ts","names":[],"sources":["../../../src/utils/booleans.tsx"],"mappings":";KAAY,MAAA,MAAY,CAAA;AAAA,KACZ,KAAA,MAAW,CAAA;AAAA,iBAEP,QAAA,GAAA,CAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,MAAA,CAAO,CAAA;AAAA,iBAgB3C,OAAA,GAAA,CAAW,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,KAAA,CAAM,CAAA"}
+{"version":3,"file":"booleans.d.ts","names":[],"sources":["../../../src/utils/booleans.tsx"],"mappings":";KAAY,MAAA,MAAY,CAAC;AAAA,KACb,KAAA,MAAW,CAAC;AAAA,iBAER,QAAA,IAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,MAAA,CAAO,CAAA;AAAA,iBAgB3C,OAAA,IAAW,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,KAAA,CAAM,CAAA"}

package/dist/esm/utils/booleans.js

@@ -2,34 +2,10 @@
 function isTruthy(value) {
 	return !!value;
 }
-(void 0)?.test("isTruthy", ({ expect }) => {
-	expect(isTruthy(true)).toBe(true);
-	expect(isTruthy(1)).toBe(true);
-	expect(isTruthy("hello")).toBe(true);
-	expect(isTruthy({})).toBe(true);
-	expect(isTruthy([])).toBe(true);
-	expect(isTruthy(false)).toBe(false);
-	expect(isTruthy(0)).toBe(false);
-	expect(isTruthy("")).toBe(false);
-	expect(isTruthy(null)).toBe(false);
-	expect(isTruthy(void 0)).toBe(false);
-});
 function isFalsy(value) {
 	return !value;
 }
-(void 0)?.test("isFalsy", ({ expect }) => {
-	expect(isFalsy(false)).toBe(true);
-	expect(isFalsy(0)).toBe(true);
-	expect(isFalsy("")).toBe(true);
-	expect(isFalsy(null)).toBe(true);
-	expect(isFalsy(void 0)).toBe(true);
-	expect(isFalsy(true)).toBe(false);
-	expect(isFalsy(1)).toBe(false);
-	expect(isFalsy("hello")).toBe(false);
-	expect(isFalsy({})).toBe(false);
-	expect(isFalsy([])).toBe(false);
-});
-
 //#endregion
 export { isFalsy, isTruthy };
+
 //# sourceMappingURL=booleans.js.map

package/dist/esm/utils/booleans.js.map

@@ -1 +1 @@
-{"version":3,"file":"booleans.js","names":[],"sources":["../../../src/utils/booleans.tsx"],"sourcesContent":["export type Truthy<T> = T extends null | undefined | 0 | \"\" | false ? false : true;\nexport type Falsy<T> = T extends null | undefined | 0 | \"\" | false ? true : false;\n\nexport function isTruthy<T>(value: T): value is T & Truthy<T> {\n  return !!value;\n}\nimport.meta.vitest?.test(\"isTruthy\", ({ expect }) => {\n  expect(isTruthy(true)).toBe(true);\n  expect(isTruthy(1)).toBe(true);\n  expect(isTruthy(\"hello\")).toBe(true);\n  expect(isTruthy({})).toBe(true);\n  expect(isTruthy([])).toBe(true);\n  expect(isTruthy(false)).toBe(false);\n  expect(isTruthy(0)).toBe(false);\n  expect(isTruthy(\"\")).toBe(false);\n  expect(isTruthy(null)).toBe(false);\n  expect(isTruthy(undefined)).toBe(false);\n});\n\nexport function isFalsy<T>(value: T): value is T & Falsy<T> {\n  return !value;\n}\nimport.meta.vitest?.test(\"isFalsy\", ({ expect }) => {\n  expect(isFalsy(false)).toBe(true);\n  expect(isFalsy(0)).toBe(true);\n  expect(isFalsy(\"\")).toBe(true);\n  expect(isFalsy(null)).toBe(true);\n  expect(isFalsy(undefined)).toBe(true);\n  expect(isFalsy(true)).toBe(false);\n  expect(isFalsy(1)).toBe(false);\n  expect(isFalsy(\"hello\")).toBe(false);\n  expect(isFalsy({})).toBe(false);\n  expect(isFalsy([])).toBe(false);\n});\n"],"mappings":";AAGA,SAAgB,SAAY,OAAkC;AAC5D,QAAO,CAAC,CAAC;;CAEX,SAAW,KAAC,aAAc,EAAA,aAAc;AACtC,QAAO,SAAS,KAAK,CAAC,CAAC,KAAK,KAAK;AACjC,QAAO,SAAS,EAAE,CAAC,CAAC,KAAK,KAAK;AAC9B,QAAO,SAAS,QAAQ,CAAC,CAAC,KAAK,KAAK;AACpC,QAAO,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK;AAC/B,QAAO,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK;AAC/B,QAAO,SAAS,MAAM,CAAC,CAAC,KAAK,MAAM;AACnC,QAAO,SAAS,EAAE,CAAC,CAAC,KAAK,MAAM;AAC/B,QAAO,SAAS,GAAG,CAAC,CAAC,KAAK,MAAM;AAChC,QAAO,SAAS,KAAK,CAAC,CAAC,KAAK,MAAM;AAClC,QAAO,SAAS,OAAU,CAAC,CAAC,KAAK,MAAM;EACvC;AAEF,SAAgB,QAAW,OAAiC;AAC1D,QAAO,CAAC;;CAEV,SAAW,KAAC,YAAc,EAAA,aAAa;AACrC,QAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,KAAK;AACjC,QAAO,QAAQ,EAAE,CAAC,CAAC,KAAK,KAAK;AAC7B,QAAO,QAAQ,GAAG,CAAC,CAAC,KAAK,KAAK;AAC9B,QAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,KAAK;AAChC,QAAO,QAAQ,OAAU,CAAC,CAAC,KAAK,KAAK;AACrC,QAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,MAAM;AACjC,QAAO,QAAQ,EAAE,CAAC,CAAC,KAAK,MAAM;AAC9B,QAAO,QAAQ,QAAQ,CAAC,CAAC,KAAK,MAAM;AACpC,QAAO,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM;AAC/B,QAAO,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM;EAC/B"}
+{"version":3,"file":"booleans.js","names":[],"sources":["../../../src/utils/booleans.tsx"],"sourcesContent":["export type Truthy<T> = T extends null | undefined | 0 | \"\" | false ? false : true;\nexport type Falsy<T> = T extends null | undefined | 0 | \"\" | false ? true : false;\n\nexport function isTruthy<T>(value: T): value is T & Truthy<T> {\n  return !!value;\n}\nimport.meta.vitest?.test(\"isTruthy\", ({ expect }) => {\n  expect(isTruthy(true)).toBe(true);\n  expect(isTruthy(1)).toBe(true);\n  expect(isTruthy(\"hello\")).toBe(true);\n  expect(isTruthy({})).toBe(true);\n  expect(isTruthy([])).toBe(true);\n  expect(isTruthy(false)).toBe(false);\n  expect(isTruthy(0)).toBe(false);\n  expect(isTruthy(\"\")).toBe(false);\n  expect(isTruthy(null)).toBe(false);\n  expect(isTruthy(undefined)).toBe(false);\n});\n\nexport function isFalsy<T>(value: T): value is T & Falsy<T> {\n  return !value;\n}\nimport.meta.vitest?.test(\"isFalsy\", ({ expect }) => {\n  expect(isFalsy(false)).toBe(true);\n  expect(isFalsy(0)).toBe(true);\n  expect(isFalsy(\"\")).toBe(true);\n  expect(isFalsy(null)).toBe(true);\n  expect(isFalsy(undefined)).toBe(true);\n  expect(isFalsy(true)).toBe(false);\n  expect(isFalsy(1)).toBe(false);\n  expect(isFalsy(\"hello\")).toBe(false);\n  expect(isFalsy({})).toBe(false);\n  expect(isFalsy([])).toBe(false);\n});\n"],"mappings":";AAGA,SAAgB,SAAY,OAAkC;CAC5D,OAAO,CAAC,CAAC;AACX;AAcA,SAAgB,QAAW,OAAiC;CAC1D,OAAO,CAAC;AACV"}

package/dist/esm/utils/browser-compat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-compat.d.ts","names":[],"sources":["../../../src/utils/browser-compat.tsx"],"mappings":";iBAAgB,6BAAA,CAAA"}
+{"version":3,"file":"browser-compat.d.ts","names":[],"sources":["../../../src/utils/browser-compat.tsx"],"mappings":";iBAAgB,6BAAA"}

package/dist/esm/utils/browser-compat.js

@@ -15,7 +15,7 @@ function getBrowserCompatibilityReport() {
 		cryptoUuid: test("crypto.randomUUID()")
 	};
 }
-
 //#endregion
 export { getBrowserCompatibilityReport };
+
 //# sourceMappingURL=browser-compat.js.map

package/dist/esm/utils/browser-compat.js.map

@@ -1 +1 @@
-{"version":3,"file":"browser-compat.js","names":[],"sources":["../../../src/utils/browser-compat.tsx"],"sourcesContent":["export function getBrowserCompatibilityReport() {\n  const test = (snippet: string) => {\n    try {\n      (0, eval)(snippet);\n      return true;\n    } catch (e) {\n      return `FAILED: ${e}`;\n    }\n  };\n\n  return {\n    optionalChaining: test(\"({})?.b?.c\"),\n    nullishCoalescing: test(\"0 ?? 1\"),\n    weakRef: test(\"new WeakRef({})\"),\n    cryptoUuid: test(\"crypto.randomUUID()\"),\n  };\n}\n"],"mappings":";AAAA,SAAgB,gCAAgC;CAC9C,MAAM,QAAQ,YAAoB;AAChC,MAAI;AACF,IAAC,GAAG,MAAM,QAAQ;AAClB,UAAO;WACA,GAAG;AACV,UAAO,WAAW;;;AAItB,QAAO;EACL,kBAAkB,KAAK,aAAa;EACpC,mBAAmB,KAAK,SAAS;EACjC,SAAS,KAAK,kBAAkB;EAChC,YAAY,KAAK,sBAAsB;EACxC"}
+{"version":3,"file":"browser-compat.js","names":[],"sources":["../../../src/utils/browser-compat.tsx"],"sourcesContent":["export function getBrowserCompatibilityReport() {\n  const test = (snippet: string) => {\n    try {\n      (0, eval)(snippet);\n      return true;\n    } catch (e) {\n      return `FAILED: ${e}`;\n    }\n  };\n\n  return {\n    optionalChaining: test(\"({})?.b?.c\"),\n    nullishCoalescing: test(\"0 ?? 1\"),\n    weakRef: test(\"new WeakRef({})\"),\n    cryptoUuid: test(\"crypto.randomUUID()\"),\n  };\n}\n"],"mappings":";AAAA,SAAgB,gCAAgC;CAC9C,MAAM,QAAQ,YAAoB;EAChC,IAAI;GACF,CAAC,GAAG,KAAA,CAAM,OAAO;GACjB,OAAO;EACT,SAAS,GAAG;GACV,OAAO,WAAW;EACpB;CACF;CAEA,OAAO;EACL,kBAAkB,KAAK,YAAY;EACnC,mBAAmB,KAAK,QAAQ;EAChC,SAAS,KAAK,iBAAiB;EAC/B,YAAY,KAAK,qBAAqB;CACxC;AACF"}

package/dist/esm/utils/bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.d.ts","names":[],"sources":["../../../src/utils/bytes.tsx"],"mappings":";iBASgB,WAAA,CAAY,KAAA,EAAO,UAAA;AAAA,iBAYnB,2BAAA,CAA4B,KAAA;AAAA,iBAY5B,2BAAA,CAA4B,SAAA;AAAA,iBAgB5B,YAAA,CAAa,KAAA,EAAO,UAAA;AAAA,iBA+BpB,YAAA,CAAa,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBAiCxC,YAAA,CAAa,KAAA,EAAO,UAAA;AAAA,iBAIpB,YAAA,CAAa,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBAsDxC,eAAA,CAAgB,KAAA,EAAO,UAAA;AAAA,iBAQvB,eAAA,CAAgB,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBA+B3C,uBAAA,CAAwB,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBAwBnD,QAAA,CAAS,KAAA;AAAA,iBAmBT,QAAA,CAAS,KAAA;AAAA,iBAaT,WAAA,CAAY,KAAA"}
+{"version":3,"file":"bytes.d.ts","names":[],"sources":["../../../src/utils/bytes.tsx"],"mappings":";iBASgB,WAAA,CAAY,KAAiB,EAAV,UAAU;AAAA,iBAY7B,2BAAA,CAA4B,KAAa;AAAA,iBAYzC,2BAAA,CAA4B,SAAiB;AAAA,iBAgB7C,YAAA,CAAa,KAAiB,EAAV,UAAU;AAAA,iBA+B9B,YAAA,CAAa,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBAiCxC,YAAA,CAAa,KAAiB,EAAV,UAAU;AAAA,iBAI9B,YAAA,CAAa,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBAsDxC,eAAA,CAAgB,KAAiB,EAAV,UAAU;AAAA,iBAQjC,eAAA,CAAgB,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBA+B3C,uBAAA,CAAwB,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBAwBnD,QAAA,CAAS,KAAa;AAAA,iBAmBtB,QAAA,CAAS,KAAa;AAAA,iBAatB,WAAA,CAAY,KAAa"}

package/dist/esm/utils/bytes.js

@@ -1,8 +1,7 @@
 import { HexclaveAssertionError } from "./errors.js";
-
 //#region src/utils/bytes.tsx
 const crockfordAlphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-const crockfordReplacements = new Map([
+const crockfordReplacements = /* @__PURE__ */ new Map([
 	["o", "0"],
 	["i", "1"],
 	["l", "1"]
@@ -10,38 +9,16 @@ const crockfordReplacements = new Map([
 function toHexString(input) {
 	return Array.from(input).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-(void 0)?.test("toHexString", ({ expect }) => {
-	expect(toHexString(new Uint8Array([]))).toBe("");
-	expect(toHexString(new Uint8Array([0]))).toBe("00");
-	expect(toHexString(new Uint8Array([15]))).toBe("0f");
-	expect(toHexString(new Uint8Array([16]))).toBe("10");
-	expect(toHexString(new Uint8Array([255]))).toBe("ff");
-	expect(toHexString(new Uint8Array([
-		1,
-		2,
-		3
-	]))).toBe("010203");
-});
 function getBase32CharacterFromIndex(index) {
 	if (index < 0 || index >= 32) throw new HexclaveAssertionError(`Invalid base32 index: ${index}`);
 	return crockfordAlphabet[index];
 }
-(void 0)?.test("getBase32CharacterFromIndex", ({ expect }) => {
-	expect(getBase32CharacterFromIndex(0)).toBe("0");
-	expect(getBase32CharacterFromIndex(15)).toBe("F");
-	expect(() => getBase32CharacterFromIndex(32)).toThrow();
-});
 function getBase32IndexFromCharacter(character) {
 	if (character.length !== 1) throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);
 	const index = crockfordAlphabet.indexOf(character.toUpperCase());
 	if (index === -1) throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);
 	return index;
 }
-(void 0)?.test("getBase32IndexFromCharacter", ({ expect }) => {
-	expect(getBase32IndexFromCharacter("0")).toBe(0);
-	expect(getBase32IndexFromCharacter("F")).toBe(15);
-	expect(() => getBase32IndexFromCharacter("_")).toThrow();
-});
 function encodeBase32(input) {
 	let bits = 0;
 	let value = 0;
@@ -58,14 +35,6 @@ function encodeBase32(input) {
 	if (!isBase32(output)) throw new HexclaveAssertionError("Invalid base32 output; this should never happen");
 	return output;
 }
-(void 0)?.test("encodeBase32", ({ expect }) => {
-	expect(encodeBase32(new Uint8Array([]))).toBe("");
-	expect(encodeBase32(new Uint8Array([1]))).toBe("04");
-	expect(encodeBase32(new Uint8Array([15]))).toBe("1W");
-	expect(encodeBase32(new Uint8Array([16]))).toBe("20");
-	expect(encodeBase32(new Uint8Array([255]))).toBe("ZW");
-	expect(encodeBase32(new Uint8Array([255, 255]))).toBe("ZZZG");
-});
 function decodeBase32(input) {
 	if (!isBase32(input)) throw new HexclaveAssertionError("Invalid base32 string");
 	const output = new Uint8Array(input.length * 5 / 8 | 0);
@@ -86,168 +55,25 @@ function decodeBase32(input) {
 	}
 	return output;
 }
-(void 0)?.test("decodeBase32", ({ expect }) => {
-	expect(decodeBase32("")).toEqual(new Uint8Array([]));
-	expect(decodeBase32("00")).toEqual(new Uint8Array([0]));
-	expect(decodeBase32("1W")).toEqual(new Uint8Array([15]));
-	expect(decodeBase32("20")).toEqual(new Uint8Array([16]));
-	expect(decodeBase32("ZW")).toEqual(new Uint8Array([255]));
-});
 function encodeBase64(input) {
 	return btoa([...input].map((b) => String.fromCharCode(b)).join(""));
 }
 function decodeBase64(input) {
 	return new Uint8Array(atob(input).split("").map((char) => char.charCodeAt(0)));
 }
-(void 0)?.test("encodeBase64/decodeBase64", ({ expect }) => {
-	const testCases = [
-		{
-			input: new Uint8Array([
-				72,
-				101,
-				108,
-				108,
-				111
-			]),
-			expected: "SGVsbG8="
-		},
-		{
-			input: new Uint8Array([
-				0,
-				1,
-				2,
-				3,
-				4
-			]),
-			expected: "AAECAwQ="
-		},
-		{
-			input: new Uint8Array([
-				255,
-				254,
-				253,
-				252
-			]),
-			expected: "//79/A=="
-		},
-		{
-			input: new Uint8Array([]),
-			expected: ""
-		},
-		{
-			input: (() => {
-				const input = new Uint8Array(3 * 2 ** 24);
-				for (let i = 0; i < input.length / 3; i++) {
-					input[3 * i] = Math.floor(i / 256 / 256);
-					input[3 * i + 1] = Math.floor(i / 256) % 256;
-					input[3 * i + 2] = i % 256;
-				}
-				return input;
-			})(),
-			expected: (() => {
-				const base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-				const output = [];
-				for (let i = 0; i < 2 ** 24; i++) output.push(base64Alphabet[Math.floor(i / 64 / 64 / 64)] + base64Alphabet[Math.floor(i / 64 / 64) % 64] + base64Alphabet[Math.floor(i / 64) % 64] + base64Alphabet[i % 64]);
-				return output.join("");
-			})()
-		}
-	];
-	for (const [i, { input, expected }] of testCases.entries()) {
-		const encoded = encodeBase64(input);
-		if (encoded !== expected) throw new HexclaveAssertionError(`encodeBase64 test case ${i} failed`);
-		if (decodeBase64(encoded).some((b, i) => b !== input[i])) throw new HexclaveAssertionError(`decodeBase64 test case ${i} failed`);
-	}
-	expect(() => decodeBase64("invalid!")).toThrow();
-}, { timeout: 3e4 });
 function encodeBase64Url(input) {
 	return encodeBase64(input).replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
 }
 function decodeBase64Url(input) {
 	if (!isBase64Url(input)) throw new HexclaveAssertionError("Invalid base64url string");
-	if (input === "") return new Uint8Array(0);
+	if (input === "") return /* @__PURE__ */ new Uint8Array(0);
 	return decodeBase64(input.replace(/-/g, "+").replace(/_/g, "/") + "====".slice((input.length - 1) % 4 + 1));
 }
-(void 0)?.test("encodeBase64Url/decodeBase64Url", ({ expect }) => {
-	const testCases = [
-		{
-			input: new Uint8Array([
-				72,
-				101,
-				108,
-				108,
-				111
-			]),
-			expected: "SGVsbG8"
-		},
-		{
-			input: new Uint8Array([
-				0,
-				1,
-				2,
-				3,
-				4
-			]),
-			expected: "AAECAwQ"
-		},
-		{
-			input: new Uint8Array([
-				255,
-				254,
-				253,
-				252
-			]),
-			expected: "__79_A"
-		},
-		{
-			input: new Uint8Array([]),
-			expected: ""
-		}
-	];
-	for (const { input, expected } of testCases) {
-		const encoded = encodeBase64Url(input);
-		expect(encoded).toBe(expected);
-		expect(decodeBase64Url(encoded)).toEqual(input);
-	}
-	expect(() => decodeBase64Url("invalid!")).toThrow();
-});
 function decodeBase64OrBase64Url(input) {
 	if (isBase64Url(input)) return decodeBase64Url(input);
 	else if (isBase64(input)) return decodeBase64(input);
 	else throw new HexclaveAssertionError("Invalid base64 or base64url string");
 }
-(void 0)?.test("decodeBase64OrBase64Url", ({ expect }) => {
-	const base64Input = "SGVsbG8gV29ybGQ=";
-	const base64Expected = new Uint8Array([
-		72,
-		101,
-		108,
-		108,
-		111,
-		32,
-		87,
-		111,
-		114,
-		108,
-		100
-	]);
-	expect(decodeBase64OrBase64Url(base64Input)).toEqual(base64Expected);
-	const base64UrlInput = "SGVsbG8gV29ybGQ";
-	const base64UrlExpected = new Uint8Array([
-		72,
-		101,
-		108,
-		108,
-		111,
-		32,
-		87,
-		111,
-		114,
-		108,
-		100
-	]);
-	expect(decodeBase64OrBase64Url(base64UrlInput)).toEqual(base64UrlExpected);
-	expect(() => decodeBase64OrBase64Url("invalid!")).toThrow();
-});
 function isBase32(input) {
 	for (const char of input) {
 		if (char === " ") continue;
@@ -256,35 +82,14 @@ function isBase32(input) {
 	}
 	return true;
 }
-(void 0)?.test("isBase32", ({ expect }) => {
-	expect(isBase32("0123456789ABCDEFGHJKMNPQRSTVWXYZ")).toBe(true);
-	expect(isBase32("0OIJ")).toBe(false);
-	expect(isBase32("ABC DEF")).toBe(true);
-	expect(isBase32("ABC!")).toBe(false);
-	expect(isBase32("")).toBe(true);
-});
 function isBase64(input) {
 	return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(input);
 }
-(void 0)?.test("isBase64", ({ expect }) => {
-	expect(isBase64("SGVsbG8gV29ybGQ=")).toBe(true);
-	expect(isBase64("SGVsbG8gV29ybGQ")).toBe(false);
-	expect(isBase64("SGVsbG8gV29ybGQ==")).toBe(false);
-	expect(isBase64("SGVsbG8!V29ybGQ=")).toBe(false);
-	expect(isBase64("")).toBe(true);
-});
 function isBase64Url(input) {
 	if (input === "") return true;
 	return /^[0-9a-zA-Z_-]+$/.test(input);
 }
-(void 0)?.test("isBase64Url", ({ expect }) => {
-	expect(isBase64Url("SGVsbG8gV2 9ybGQ")).toBe(false);
-	expect(isBase64Url("SGVsbG8_V29ybGQ")).toBe(true);
-	expect(isBase64Url("SGVsbG8-V29ybGQ")).toBe(true);
-	expect(isBase64Url("SGVsbG8_V29ybGQ=")).toBe(false);
-	expect(isBase64Url("")).toBe(true);
-});
-
 //#endregion
 export { decodeBase32, decodeBase64, decodeBase64OrBase64Url, decodeBase64Url, encodeBase32, encodeBase64, encodeBase64Url, getBase32CharacterFromIndex, getBase32IndexFromCharacter, isBase32, isBase64, isBase64Url, toHexString };
+
 //# sourceMappingURL=bytes.js.map

package/dist/esm/utils/bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.js","names":[],"sources":["../../../src/utils/bytes.tsx"],"sourcesContent":["import { HexclaveAssertionError } from \"./errors\";\n\nconst crockfordAlphabet = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\";\nconst crockfordReplacements = new Map([\n  [\"o\", \"0\"],\n  [\"i\", \"1\"],\n  [\"l\", \"1\"],\n]);\n\nexport function toHexString(input: Uint8Array): string {\n  return Array.from(input).map(b => b.toString(16).padStart(2, \"0\")).join(\"\");\n}\nimport.meta.vitest?.test(\"toHexString\", ({ expect }) => {\n  expect(toHexString(new Uint8Array([]))).toBe(\"\");\n  expect(toHexString(new Uint8Array([0]))).toBe(\"00\");\n  expect(toHexString(new Uint8Array([15]))).toBe(\"0f\");\n  expect(toHexString(new Uint8Array([16]))).toBe(\"10\");\n  expect(toHexString(new Uint8Array([255]))).toBe(\"ff\");\n  expect(toHexString(new Uint8Array([1, 2, 3]))).toBe(\"010203\");\n});\n\nexport function getBase32CharacterFromIndex(index: number): string {\n  if (index < 0 || index >= crockfordAlphabet.length) {\n    throw new HexclaveAssertionError(`Invalid base32 index: ${index}`);\n  }\n  return crockfordAlphabet[index];\n}\nimport.meta.vitest?.test(\"getBase32CharacterFromIndex\", ({ expect }) => {\n  expect(getBase32CharacterFromIndex(0)).toBe(\"0\");\n  expect(getBase32CharacterFromIndex(15)).toBe(\"F\");\n  expect(() => getBase32CharacterFromIndex(32)).toThrow();\n});\n\nexport function getBase32IndexFromCharacter(character: string): number {\n  if (character.length !== 1) {\n    throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);\n  }\n  const index = crockfordAlphabet.indexOf(character.toUpperCase());\n  if (index === -1) {\n    throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);\n  }\n  return index;\n}\nimport.meta.vitest?.test(\"getBase32IndexFromCharacter\", ({ expect }) => {\n  expect(getBase32IndexFromCharacter(\"0\")).toBe(0);\n  expect(getBase32IndexFromCharacter(\"F\")).toBe(15);\n  expect(() => getBase32IndexFromCharacter(\"_\")).toThrow();\n});\n\nexport function encodeBase32(input: Uint8Array): string {\n  let bits = 0;\n  let value = 0;\n  let output = \"\";\n  for (let i = 0; i < input.length; i++) {\n    value = (value << 8) | input[i];\n    bits += 8;\n    while (bits >= 5) {\n      output += getBase32CharacterFromIndex((value >>> (bits - 5)) & 31);\n      bits -= 5;\n    }\n  }\n  if (bits > 0) {\n    output += getBase32CharacterFromIndex((value << (5 - bits)) & 31);\n  }\n\n  // sanity check\n  if (!isBase32(output)) {\n    throw new HexclaveAssertionError(\"Invalid base32 output; this should never happen\");\n  }\n\n  return output;\n}\nimport.meta.vitest?.test(\"encodeBase32\", ({ expect }) => {\n  expect(encodeBase32(new Uint8Array([]))).toBe(\"\");\n  expect(encodeBase32(new Uint8Array([1]))).toBe(\"04\");\n  expect(encodeBase32(new Uint8Array([15]))).toBe(\"1W\");\n  expect(encodeBase32(new Uint8Array([16]))).toBe(\"20\");\n  expect(encodeBase32(new Uint8Array([255]))).toBe(\"ZW\");\n  expect(encodeBase32(new Uint8Array([255,255]))).toBe(\"ZZZG\");\n});\nexport function decodeBase32(input: string): Uint8Array<ArrayBuffer> {\n  if (!isBase32(input)) {\n    throw new HexclaveAssertionError(\"Invalid base32 string\");\n  }\n\n  const output = new Uint8Array((input.length * 5 / 8) | 0);\n  let bits = 0;\n  let value = 0;\n  let outputIndex = 0;\n  for (let i = 0; i < input.length; i++) {\n    let char = input[i].toLowerCase();\n    if (char === \" \") continue;\n    if (crockfordReplacements.has(char)) {\n      char = crockfordReplacements.get(char)!;\n    }\n    const index = getBase32IndexFromCharacter(char);\n    value = (value << 5) | index;\n    bits += 5;\n    if (bits >= 8) {\n      output[outputIndex++] = (value >>> (bits - 8)) & 255;\n      bits -= 8;\n    }\n  }\n  return output;\n}\nimport.meta.vitest?.test(\"decodeBase32\", ({ expect }) => {\n  expect(decodeBase32(\"\")).toEqual(new Uint8Array([]));\n  expect(decodeBase32(\"00\")).toEqual(new Uint8Array([0]));\n  expect(decodeBase32(\"1W\")).toEqual(new Uint8Array([15]));\n  expect(decodeBase32(\"20\")).toEqual(new Uint8Array([16]));\n  expect(decodeBase32(\"ZW\")).toEqual(new Uint8Array([255]));\n});\n\nexport function encodeBase64(input: Uint8Array): string {\n  return btoa([...input].map((b) => String.fromCharCode(b)).join(\"\"));\n}\n\nexport function decodeBase64(input: string): Uint8Array<ArrayBuffer> {\n  return new Uint8Array(atob(input).split(\"\").map((char) => char.charCodeAt(0)));\n}\nimport.meta.vitest?.test(\"encodeBase64/decodeBase64\", ({ expect }) => {\n  const testCases = [\n    { input: new Uint8Array([72, 101, 108, 108, 111]), expected: \"SGVsbG8=\" },\n    { input: new Uint8Array([0, 1, 2, 3, 4]), expected: \"AAECAwQ=\" },\n    { input: new Uint8Array([255, 254, 253, 252]), expected: \"//79/A==\" },\n    { input: new Uint8Array([]), expected: \"\" },\n    {\n      input: (() => {\n        // make sure huge inputs are supported; 48MB array of every possible triple-byte combination\n        const input = new Uint8Array(3 * (2 ** 24));\n        for (let i = 0; i < input.length / 3; i++) {\n          input[3 * i] = Math.floor(i / 256 / 256);\n          input[3 * i + 1] = Math.floor(i / 256) % 256;\n          input[3 * i + 2] = i % 256;\n        }\n        return input;\n      })(),\n      expected: (() => {\n        const base64Alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n        const output = [];\n        for (let i = 0; i < 2 ** 24; i++) {\n          output.push(\n            base64Alphabet[Math.floor(i / 64 / 64 / 64)]\n              + base64Alphabet[Math.floor(i / 64 / 64) % 64]\n              + base64Alphabet[Math.floor(i / 64) % 64]\n              + base64Alphabet[i % 64]\n          );\n        }\n        return output.join(\"\");\n      })(),\n    },\n  ];\n\n  for (const [i, { input, expected }] of testCases.entries()) {\n    // expect(...) is pretty slow with long inputs, so we throw our own assertions\n    const encoded = encodeBase64(input);\n    if (encoded !== expected) {\n      throw new HexclaveAssertionError(`encodeBase64 test case ${i} failed`);\n    }\n    const decoded = decodeBase64(encoded);\n    if (decoded.some((b, i) => b !== input[i])) {\n      throw new HexclaveAssertionError(`decodeBase64 test case ${i} failed`);\n    }\n  }\n\n  // Test invalid input for decodeBase64\n  expect(() => decodeBase64(\"invalid!\")).toThrow();\n}, {\n  timeout: 30000,\n});\n\nexport function encodeBase64Url(input: Uint8Array): string {\n  const res = encodeBase64(input).replace(/=+$/, \"\").replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n\n  // Skip sanity check for test cases\n  // This avoids circular dependency with isBase64Url function\n  return res;\n}\n\nexport function decodeBase64Url(input: string): Uint8Array<ArrayBuffer> {\n  if (!isBase64Url(input)) {\n    throw new HexclaveAssertionError(\"Invalid base64url string\");\n  }\n\n  // Handle empty string case\n  if (input === \"\") {\n    return new Uint8Array(0);\n  }\n\n  return decodeBase64(input.replace(/-/g, \"+\").replace(/_/g, \"/\") + \"====\".slice((input.length - 1) % 4 + 1));\n}\nimport.meta.vitest?.test(\"encodeBase64Url/decodeBase64Url\", ({ expect }) => {\n  const testCases = [\n    { input: new Uint8Array([72, 101, 108, 108, 111]), expected: \"SGVsbG8\" },\n    { input: new Uint8Array([0, 1, 2, 3, 4]), expected: \"AAECAwQ\" },\n    { input: new Uint8Array([255, 254, 253, 252]), expected: \"__79_A\" },\n    { input: new Uint8Array([]), expected: \"\" },\n  ];\n\n  for (const { input, expected } of testCases) {\n    const encoded = encodeBase64Url(input);\n    expect(encoded).toBe(expected);\n    const decoded = decodeBase64Url(encoded);\n    expect(decoded).toEqual(input);\n  }\n\n  // Test invalid input for decodeBase64Url\n  expect(() => decodeBase64Url(\"invalid!\")).toThrow();\n});\n\nexport function decodeBase64OrBase64Url(input: string): Uint8Array<ArrayBuffer> {\n  if (isBase64Url(input)) {\n    return decodeBase64Url(input);\n  } else if (isBase64(input)) {\n    return decodeBase64(input);\n  } else {\n    throw new HexclaveAssertionError(\"Invalid base64 or base64url string\");\n  }\n}\nimport.meta.vitest?.test(\"decodeBase64OrBase64Url\", ({ expect }) => {\n  // Test with base64 input\n  const base64Input = \"SGVsbG8gV29ybGQ=\";\n  const base64Expected = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);\n  expect(decodeBase64OrBase64Url(base64Input)).toEqual(base64Expected);\n\n  // Test with base64url input\n  const base64UrlInput = \"SGVsbG8gV29ybGQ\";\n  const base64UrlExpected = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);\n  expect(decodeBase64OrBase64Url(base64UrlInput)).toEqual(base64UrlExpected);\n\n  // Test with invalid input\n  expect(() => decodeBase64OrBase64Url(\"invalid!\")).toThrow();\n});\n\nexport function isBase32(input: string): boolean {\n  for (const char of input) {\n    if (char === \" \") continue;\n    const upperChar = char.toUpperCase();\n    // Check if the character is in the Crockford alphabet\n    if (!crockfordAlphabet.includes(upperChar)) {\n      return false;\n    }\n  }\n  return true;\n}\nimport.meta.vitest?.test(\"isBase32\", ({ expect }) => {\n  expect(isBase32(\"0123456789ABCDEFGHJKMNPQRSTVWXYZ\")).toBe(true);\n  expect(isBase32(\"0OIJ\")).toBe(false); // O and I are not allowed\n  expect(isBase32(\"ABC DEF\")).toBe(true); // Spaces are allowed\n  expect(isBase32(\"ABC!\")).toBe(false); // Special characters not allowed\n  expect(isBase32(\"\")).toBe(true);\n});\n\nexport function isBase64(input: string): boolean {\n  // This regex allows for standard base64 with proper padding\n  const regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;\n  return regex.test(input);\n}\nimport.meta.vitest?.test(\"isBase64\", ({ expect }) => {\n  expect(isBase64(\"SGVsbG8gV29ybGQ=\")).toBe(true);\n  expect(isBase64(\"SGVsbG8gV29ybGQ\")).toBe(false); // No padding\n  expect(isBase64(\"SGVsbG8gV29ybGQ==\")).toBe(false); // Wrong padding\n  expect(isBase64(\"SGVsbG8!V29ybGQ=\")).toBe(false); // Invalid character\n  expect(isBase64(\"\")).toBe(true);\n});\n\nexport function isBase64Url(input: string): boolean {\n  if (input === \"\") {\n    return true;\n  }\n  const regex = /^[0-9a-zA-Z_-]+$/;\n  return regex.test(input);\n}\nimport.meta.vitest?.test(\"isBase64Url\", ({ expect }) => {\n  expect(isBase64Url(\"SGVsbG8gV2 9ybGQ\")).toBe(false); // Space is not valid\n  expect(isBase64Url(\"SGVsbG8_V29ybGQ\")).toBe(true); // _ is a valid character\n  expect(isBase64Url(\"SGVsbG8-V29ybGQ\")).toBe(true); // - is valid\n  expect(isBase64Url(\"SGVsbG8_V29ybGQ=\")).toBe(false); // = not allowed\n  expect(isBase64Url(\"\")).toBe(true); // Empty string is valid\n});\n"],"mappings":";;;AAEA,MAAM,oBAAoB;AAC1B,MAAM,wBAAwB,IAAI,IAAI;CACpC,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACV,CAAC,KAAK,IAAI;CACX,CAAC;AAEF,SAAgB,YAAY,OAA2B;AACrD,QAAO,MAAM,KAAK,MAAM,CAAC,KAAI,MAAK,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,KAAK,GAAG;;CAE7E,SAAW,KAAC,gBAAc,EAAA,aAAiB;AACzC,QAAO,YAAY,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG;AAChD,QAAO,YAAY,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACnD,QAAO,YAAY,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACpD,QAAO,YAAY,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACpD,QAAO,YAAY,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACrD,QAAO,YAAY,IAAI,WAAW;EAAC;EAAG;EAAG;EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS;EAC7D;AAEF,SAAgB,4BAA4B,OAAuB;AACjE,KAAI,QAAQ,KAAK,SAAS,GACxB,OAAM,IAAI,uBAAuB,yBAAyB,QAAQ;AAEpE,QAAO,kBAAkB;;CAE3B,SAAW,KAAC,gCAAc,EAAA,aAAiC;AACzD,QAAO,4BAA4B,EAAE,CAAC,CAAC,KAAK,IAAI;AAChD,QAAO,4BAA4B,GAAG,CAAC,CAAC,KAAK,IAAI;AACjD,cAAa,4BAA4B,GAAG,CAAC,CAAC,SAAS;EACvD;AAEF,SAAgB,4BAA4B,WAA2B;AACrE,KAAI,UAAU,WAAW,EACvB,OAAM,IAAI,uBAAuB,6BAA6B,YAAY;CAE5E,MAAM,QAAQ,kBAAkB,QAAQ,UAAU,aAAa,CAAC;AAChE,KAAI,UAAU,GACZ,OAAM,IAAI,uBAAuB,6BAA6B,YAAY;AAE5E,QAAO;;CAET,SAAW,KAAC,gCAAc,EAAA,aAAiC;AACzD,QAAO,4BAA4B,IAAI,CAAC,CAAC,KAAK,EAAE;AAChD,QAAO,4BAA4B,IAAI,CAAC,CAAC,KAAK,GAAG;AACjD,cAAa,4BAA4B,IAAI,CAAC,CAAC,SAAS;EACxD;AAEF,SAAgB,aAAa,OAA2B;CACtD,IAAI,OAAO;CACX,IAAI,QAAQ;CACZ,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,UAAS,SAAS,IAAK,MAAM;AAC7B,UAAQ;AACR,SAAO,QAAQ,GAAG;AAChB,aAAU,4BAA6B,UAAW,OAAO,IAAM,GAAG;AAClE,WAAQ;;;AAGZ,KAAI,OAAO,EACT,WAAU,4BAA6B,SAAU,IAAI,OAAS,GAAG;AAInE,KAAI,CAAC,SAAS,OAAO,CACnB,OAAM,IAAI,uBAAuB,kDAAkD;AAGrF,QAAO;;CAET,SAAW,KAAC,iBAAc,EAAA,aAAkB;AAC1C,QAAO,aAAa,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG;AACjD,QAAO,aAAa,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACpD,QAAO,aAAa,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACrD,QAAO,aAAa,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACrD,QAAO,aAAa,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;AACtD,QAAO,aAAa,IAAI,WAAW,CAAC,KAAI,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO;EAC5D;AACF,SAAgB,aAAa,OAAwC;AACnE,KAAI,CAAC,SAAS,MAAM,CAClB,OAAM,IAAI,uBAAuB,wBAAwB;CAG3D,MAAM,SAAS,IAAI,WAAY,MAAM,SAAS,IAAI,IAAK,EAAE;CACzD,IAAI,OAAO;CACX,IAAI,QAAQ;CACZ,IAAI,cAAc;AAClB,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,IAAI,OAAO,MAAM,GAAG,aAAa;AACjC,MAAI,SAAS,IAAK;AAClB,MAAI,sBAAsB,IAAI,KAAK,CACjC,QAAO,sBAAsB,IAAI,KAAK;EAExC,MAAM,QAAQ,4BAA4B,KAAK;AAC/C,UAAS,SAAS,IAAK;AACvB,UAAQ;AACR,MAAI,QAAQ,GAAG;AACb,UAAO,iBAAkB,UAAW,OAAO,IAAM;AACjD,WAAQ;;;AAGZ,QAAO;;CAET,SAAW,KAAC,iBAAc,EAAA,aAAkB;AAC1C,QAAO,aAAa,GAAG,CAAC,CAAC,QAAQ,IAAI,WAAW,EAAE,CAAC,CAAC;AACpD,QAAO,aAAa,KAAK,CAAC,CAAC,QAAQ,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;AACvD,QAAO,aAAa,KAAK,CAAC,CAAC,QAAQ,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;AACxD,QAAO,aAAa,KAAK,CAAC,CAAC,QAAQ,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;AACxD,QAAO,aAAa,KAAK,CAAC,CAAC,QAAQ,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC;EACzD;AAEF,SAAgB,aAAa,OAA2B;AACtD,QAAO,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,MAAM,OAAO,aAAa,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC;;AAGrE,SAAgB,aAAa,OAAwC;AACnE,QAAO,IAAI,WAAW,KAAK,MAAM,CAAC,MAAM,GAAG,CAAC,KAAK,SAAS,KAAK,WAAW,EAAE,CAAC,CAAC;;CAEhF,SAAW,KAAC,8BAA2B,EAAA,aAAkB;CACvD,MAAM,YAAY;EAChB;GAAE,OAAO,IAAI,WAAW;IAAC;IAAI;IAAK;IAAK;IAAK;IAAI,CAAC;GAAE,UAAU;GAAY;EACzE;GAAE,OAAO,IAAI,WAAW;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GAAE,UAAU;GAAY;EAChE;GAAE,OAAO,IAAI,WAAW;IAAC;IAAK;IAAK;IAAK;IAAI,CAAC;GAAE,UAAU;GAAY;EACrE;GAAE,OAAO,IAAI,WAAW,EAAE,CAAC;GAAE,UAAU;GAAI;EAC3C;GACE,cAAc;IAEZ,MAAM,QAAQ,IAAI,WAAW,IAAK,KAAK,GAAI;AAC3C,SAAK,IAAI,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;AACzC,WAAM,IAAI,KAAK,KAAK,MAAM,IAAI,MAAM,IAAI;AACxC,WAAM,IAAI,IAAI,KAAK,KAAK,MAAM,IAAI,IAAI,GAAG;AACzC,WAAM,IAAI,IAAI,KAAK,IAAI;;AAEzB,WAAO;OACL;GACJ,iBAAiB;IACf,MAAM,iBAAiB;IACvB,MAAM,SAAS,EAAE;AACjB,SAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IAAI,IAC3B,QAAO,KACL,eAAe,KAAK,MAAM,IAAI,KAAK,KAAK,GAAG,IACvC,eAAe,KAAK,MAAM,IAAI,KAAK,GAAG,GAAG,MACzC,eAAe,KAAK,MAAM,IAAI,GAAG,GAAG,MACpC,eAAe,IAAI,IACxB;AAEH,WAAO,OAAO,KAAK,GAAG;OACpB;GACL;EACF;AAED,MAAK,MAAM,CAAC,GAAG,EAAE,OAAO,eAAe,UAAU,SAAS,EAAE;EAE1D,MAAM,UAAU,aAAa,MAAM;AACnC,MAAI,YAAY,SACd,OAAM,IAAI,uBAAuB,0BAA0B,EAAE,SAAS;AAGxE,MADgB,aAAa,QAAQ,CACzB,MAAM,GAAG,MAAM,MAAM,MAAM,GAAG,CACxC,OAAM,IAAI,uBAAuB,0BAA0B,EAAE,SAAS;;AAK1E,cAAa,aAAa,WAAW,CAAC,CAAC,SAAS;GAC/C,EACD,SAAS,KACV,CAAC;AAEF,SAAgB,gBAAgB,OAA2B;AAKzD,QAJY,aAAa,MAAM,CAAC,QAAQ,OAAO,GAAG,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI;;AAO5F,SAAgB,gBAAgB,OAAwC;AACtE,KAAI,CAAC,YAAY,MAAM,CACrB,OAAM,IAAI,uBAAuB,2BAA2B;AAI9D,KAAI,UAAU,GACZ,QAAO,IAAI,WAAW,EAAE;AAG1B,QAAO,aAAa,MAAM,QAAQ,MAAM,IAAI,CAAC,QAAQ,MAAM,IAAI,GAAG,OAAO,OAAO,MAAM,SAAS,KAAK,IAAI,EAAE,CAAC;;CAE7G,SAAW,KAAC,oCAA8B,EAAA,aAAqB;CAC7D,MAAM,YAAY;EAChB;GAAE,OAAO,IAAI,WAAW;IAAC;IAAI;IAAK;IAAK;IAAK;IAAI,CAAC;GAAE,UAAU;GAAW;EACxE;GAAE,OAAO,IAAI,WAAW;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GAAE,UAAU;GAAW;EAC/D;GAAE,OAAO,IAAI,WAAW;IAAC;IAAK;IAAK;IAAK;IAAI,CAAC;GAAE,UAAU;GAAU;EACnE;GAAE,OAAO,IAAI,WAAW,EAAE,CAAC;GAAE,UAAU;GAAI;EAC5C;AAED,MAAK,MAAM,EAAE,OAAO,cAAc,WAAW;EAC3C,MAAM,UAAU,gBAAgB,MAAM;AACtC,SAAO,QAAQ,CAAC,KAAK,SAAS;AAE9B,SADgB,gBAAgB,QAAQ,CACzB,CAAC,QAAQ,MAAM;;AAIhC,cAAa,gBAAgB,WAAW,CAAC,CAAC,SAAS;EACnD;AAEF,SAAgB,wBAAwB,OAAwC;AAC9E,KAAI,YAAY,MAAM,CACpB,QAAO,gBAAgB,MAAM;UACpB,SAAS,MAAM,CACxB,QAAO,aAAa,MAAM;KAE1B,OAAM,IAAI,uBAAuB,qCAAqC;;CAG1E,SAAW,KAAC,4BAAc,EAAA,aAA6B;CAErD,MAAM,cAAc;CACpB,MAAM,iBAAiB,IAAI,WAAW;EAAC;EAAI;EAAK;EAAK;EAAK;EAAK;EAAI;EAAI;EAAK;EAAK;EAAK;EAAI,CAAC;AAC3F,QAAO,wBAAwB,YAAY,CAAC,CAAC,QAAQ,eAAe;CAGpE,MAAM,iBAAiB;CACvB,MAAM,oBAAoB,IAAI,WAAW;EAAC;EAAI;EAAK;EAAK;EAAK;EAAK;EAAI;EAAI;EAAK;EAAK;EAAK;EAAI,CAAC;AAC9F,QAAO,wBAAwB,eAAe,CAAC,CAAC,QAAQ,kBAAkB;AAG1E,cAAa,wBAAwB,WAAW,CAAC,CAAC,SAAS;EAC3D;AAEF,SAAgB,SAAS,OAAwB;AAC/C,MAAK,MAAM,QAAQ,OAAO;AACxB,MAAI,SAAS,IAAK;EAClB,MAAM,YAAY,KAAK,aAAa;AAEpC,MAAI,CAAC,kBAAkB,SAAS,UAAU,CACxC,QAAO;;AAGX,QAAO;;CAET,SAAW,KAAC,aAAc,EAAA,aAAc;AACtC,QAAO,SAAS,mCAAmC,CAAC,CAAC,KAAK,KAAK;AAC/D,QAAO,SAAS,OAAO,CAAC,CAAC,KAAK,MAAM;AACpC,QAAO,SAAS,UAAU,CAAC,CAAC,KAAK,KAAK;AACtC,QAAO,SAAS,OAAO,CAAC,CAAC,KAAK,MAAM;AACpC,QAAO,SAAS,GAAG,CAAC,CAAC,KAAK,KAAK;EAC/B;AAEF,SAAgB,SAAS,OAAwB;AAG/C,QADc,mEACD,KAAK,MAAM;;CAE1B,SAAW,KAAC,aAAc,EAAA,aAAc;AACtC,QAAO,SAAS,mBAAmB,CAAC,CAAC,KAAK,KAAK;AAC/C,QAAO,SAAS,kBAAkB,CAAC,CAAC,KAAK,MAAM;AAC/C,QAAO,SAAS,oBAAoB,CAAC,CAAC,KAAK,MAAM;AACjD,QAAO,SAAS,mBAAmB,CAAC,CAAC,KAAK,MAAM;AAChD,QAAO,SAAS,GAAG,CAAC,CAAC,KAAK,KAAK;EAC/B;AAEF,SAAgB,YAAY,OAAwB;AAClD,KAAI,UAAU,GACZ,QAAO;AAGT,QADc,mBACD,KAAK,MAAM;;CAE1B,SAAW,KAAC,gBAAc,EAAA,aAAiB;AACzC,QAAO,YAAY,mBAAmB,CAAC,CAAC,KAAK,MAAM;AACnD,QAAO,YAAY,kBAAkB,CAAC,CAAC,KAAK,KAAK;AACjD,QAAO,YAAY,kBAAkB,CAAC,CAAC,KAAK,KAAK;AACjD,QAAO,YAAY,mBAAmB,CAAC,CAAC,KAAK,MAAM;AACnD,QAAO,YAAY,GAAG,CAAC,CAAC,KAAK,KAAK;EAClC"}
+{"version":3,"file":"bytes.js","names":[],"sources":["../../../src/utils/bytes.tsx"],"sourcesContent":["import { HexclaveAssertionError } from \"./errors\";\n\nconst crockfordAlphabet = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\";\nconst crockfordReplacements = new Map([\n  [\"o\", \"0\"],\n  [\"i\", \"1\"],\n  [\"l\", \"1\"],\n]);\n\nexport function toHexString(input: Uint8Array): string {\n  return Array.from(input).map(b => b.toString(16).padStart(2, \"0\")).join(\"\");\n}\nimport.meta.vitest?.test(\"toHexString\", ({ expect }) => {\n  expect(toHexString(new Uint8Array([]))).toBe(\"\");\n  expect(toHexString(new Uint8Array([0]))).toBe(\"00\");\n  expect(toHexString(new Uint8Array([15]))).toBe(\"0f\");\n  expect(toHexString(new Uint8Array([16]))).toBe(\"10\");\n  expect(toHexString(new Uint8Array([255]))).toBe(\"ff\");\n  expect(toHexString(new Uint8Array([1, 2, 3]))).toBe(\"010203\");\n});\n\nexport function getBase32CharacterFromIndex(index: number): string {\n  if (index < 0 || index >= crockfordAlphabet.length) {\n    throw new HexclaveAssertionError(`Invalid base32 index: ${index}`);\n  }\n  return crockfordAlphabet[index];\n}\nimport.meta.vitest?.test(\"getBase32CharacterFromIndex\", ({ expect }) => {\n  expect(getBase32CharacterFromIndex(0)).toBe(\"0\");\n  expect(getBase32CharacterFromIndex(15)).toBe(\"F\");\n  expect(() => getBase32CharacterFromIndex(32)).toThrow();\n});\n\nexport function getBase32IndexFromCharacter(character: string): number {\n  if (character.length !== 1) {\n    throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);\n  }\n  const index = crockfordAlphabet.indexOf(character.toUpperCase());\n  if (index === -1) {\n    throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);\n  }\n  return index;\n}\nimport.meta.vitest?.test(\"getBase32IndexFromCharacter\", ({ expect }) => {\n  expect(getBase32IndexFromCharacter(\"0\")).toBe(0);\n  expect(getBase32IndexFromCharacter(\"F\")).toBe(15);\n  expect(() => getBase32IndexFromCharacter(\"_\")).toThrow();\n});\n\nexport function encodeBase32(input: Uint8Array): string {\n  let bits = 0;\n  let value = 0;\n  let output = \"\";\n  for (let i = 0; i < input.length; i++) {\n    value = (value << 8) | input[i];\n    bits += 8;\n    while (bits >= 5) {\n      output += getBase32CharacterFromIndex((value >>> (bits - 5)) & 31);\n      bits -= 5;\n    }\n  }\n  if (bits > 0) {\n    output += getBase32CharacterFromIndex((value << (5 - bits)) & 31);\n  }\n\n  // sanity check\n  if (!isBase32(output)) {\n    throw new HexclaveAssertionError(\"Invalid base32 output; this should never happen\");\n  }\n\n  return output;\n}\nimport.meta.vitest?.test(\"encodeBase32\", ({ expect }) => {\n  expect(encodeBase32(new Uint8Array([]))).toBe(\"\");\n  expect(encodeBase32(new Uint8Array([1]))).toBe(\"04\");\n  expect(encodeBase32(new Uint8Array([15]))).toBe(\"1W\");\n  expect(encodeBase32(new Uint8Array([16]))).toBe(\"20\");\n  expect(encodeBase32(new Uint8Array([255]))).toBe(\"ZW\");\n  expect(encodeBase32(new Uint8Array([255,255]))).toBe(\"ZZZG\");\n});\nexport function decodeBase32(input: string): Uint8Array<ArrayBuffer> {\n  if (!isBase32(input)) {\n    throw new HexclaveAssertionError(\"Invalid base32 string\");\n  }\n\n  const output = new Uint8Array((input.length * 5 / 8) | 0);\n  let bits = 0;\n  let value = 0;\n  let outputIndex = 0;\n  for (let i = 0; i < input.length; i++) {\n    let char = input[i].toLowerCase();\n    if (char === \" \") continue;\n    if (crockfordReplacements.has(char)) {\n      char = crockfordReplacements.get(char)!;\n    }\n    const index = getBase32IndexFromCharacter(char);\n    value = (value << 5) | index;\n    bits += 5;\n    if (bits >= 8) {\n      output[outputIndex++] = (value >>> (bits - 8)) & 255;\n      bits -= 8;\n    }\n  }\n  return output;\n}\nimport.meta.vitest?.test(\"decodeBase32\", ({ expect }) => {\n  expect(decodeBase32(\"\")).toEqual(new Uint8Array([]));\n  expect(decodeBase32(\"00\")).toEqual(new Uint8Array([0]));\n  expect(decodeBase32(\"1W\")).toEqual(new Uint8Array([15]));\n  expect(decodeBase32(\"20\")).toEqual(new Uint8Array([16]));\n  expect(decodeBase32(\"ZW\")).toEqual(new Uint8Array([255]));\n});\n\nexport function encodeBase64(input: Uint8Array): string {\n  return btoa([...input].map((b) => String.fromCharCode(b)).join(\"\"));\n}\n\nexport function decodeBase64(input: string): Uint8Array<ArrayBuffer> {\n  return new Uint8Array(atob(input).split(\"\").map((char) => char.charCodeAt(0)));\n}\nimport.meta.vitest?.test(\"encodeBase64/decodeBase64\", ({ expect }) => {\n  const testCases = [\n    { input: new Uint8Array([72, 101, 108, 108, 111]), expected: \"SGVsbG8=\" },\n    { input: new Uint8Array([0, 1, 2, 3, 4]), expected: \"AAECAwQ=\" },\n    { input: new Uint8Array([255, 254, 253, 252]), expected: \"//79/A==\" },\n    { input: new Uint8Array([]), expected: \"\" },\n    {\n      input: (() => {\n        // make sure huge inputs are supported; 48MB array of every possible triple-byte combination\n        const input = new Uint8Array(3 * (2 ** 24));\n        for (let i = 0; i < input.length / 3; i++) {\n          input[3 * i] = Math.floor(i / 256 / 256);\n          input[3 * i + 1] = Math.floor(i / 256) % 256;\n          input[3 * i + 2] = i % 256;\n        }\n        return input;\n      })(),\n      expected: (() => {\n        const base64Alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n        const output = [];\n        for (let i = 0; i < 2 ** 24; i++) {\n          output.push(\n            base64Alphabet[Math.floor(i / 64 / 64 / 64)]\n              + base64Alphabet[Math.floor(i / 64 / 64) % 64]\n              + base64Alphabet[Math.floor(i / 64) % 64]\n              + base64Alphabet[i % 64]\n          );\n        }\n        return output.join(\"\");\n      })(),\n    },\n  ];\n\n  for (const [i, { input, expected }] of testCases.entries()) {\n    // expect(...) is pretty slow with long inputs, so we throw our own assertions\n    const encoded = encodeBase64(input);\n    if (encoded !== expected) {\n      throw new HexclaveAssertionError(`encodeBase64 test case ${i} failed`);\n    }\n    const decoded = decodeBase64(encoded);\n    if (decoded.some((b, i) => b !== input[i])) {\n      throw new HexclaveAssertionError(`decodeBase64 test case ${i} failed`);\n    }\n  }\n\n  // Test invalid input for decodeBase64\n  expect(() => decodeBase64(\"invalid!\")).toThrow();\n}, {\n  timeout: 30000,\n});\n\nexport function encodeBase64Url(input: Uint8Array): string {\n  const res = encodeBase64(input).replace(/=+$/, \"\").replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n\n  // Skip sanity check for test cases\n  // This avoids circular dependency with isBase64Url function\n  return res;\n}\n\nexport function decodeBase64Url(input: string): Uint8Array<ArrayBuffer> {\n  if (!isBase64Url(input)) {\n    throw new HexclaveAssertionError(\"Invalid base64url string\");\n  }\n\n  // Handle empty string case\n  if (input === \"\") {\n    return new Uint8Array(0);\n  }\n\n  return decodeBase64(input.replace(/-/g, \"+\").replace(/_/g, \"/\") + \"====\".slice((input.length - 1) % 4 + 1));\n}\nimport.meta.vitest?.test(\"encodeBase64Url/decodeBase64Url\", ({ expect }) => {\n  const testCases = [\n    { input: new Uint8Array([72, 101, 108, 108, 111]), expected: \"SGVsbG8\" },\n    { input: new Uint8Array([0, 1, 2, 3, 4]), expected: \"AAECAwQ\" },\n    { input: new Uint8Array([255, 254, 253, 252]), expected: \"__79_A\" },\n    { input: new Uint8Array([]), expected: \"\" },\n  ];\n\n  for (const { input, expected } of testCases) {\n    const encoded = encodeBase64Url(input);\n    expect(encoded).toBe(expected);\n    const decoded = decodeBase64Url(encoded);\n    expect(decoded).toEqual(input);\n  }\n\n  // Test invalid input for decodeBase64Url\n  expect(() => decodeBase64Url(\"invalid!\")).toThrow();\n});\n\nexport function decodeBase64OrBase64Url(input: string): Uint8Array<ArrayBuffer> {\n  if (isBase64Url(input)) {\n    return decodeBase64Url(input);\n  } else if (isBase64(input)) {\n    return decodeBase64(input);\n  } else {\n    throw new HexclaveAssertionError(\"Invalid base64 or base64url string\");\n  }\n}\nimport.meta.vitest?.test(\"decodeBase64OrBase64Url\", ({ expect }) => {\n  // Test with base64 input\n  const base64Input = \"SGVsbG8gV29ybGQ=\";\n  const base64Expected = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);\n  expect(decodeBase64OrBase64Url(base64Input)).toEqual(base64Expected);\n\n  // Test with base64url input\n  const base64UrlInput = \"SGVsbG8gV29ybGQ\";\n  const base64UrlExpected = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);\n  expect(decodeBase64OrBase64Url(base64UrlInput)).toEqual(base64UrlExpected);\n\n  // Test with invalid input\n  expect(() => decodeBase64OrBase64Url(\"invalid!\")).toThrow();\n});\n\nexport function isBase32(input: string): boolean {\n  for (const char of input) {\n    if (char === \" \") continue;\n    const upperChar = char.toUpperCase();\n    // Check if the character is in the Crockford alphabet\n    if (!crockfordAlphabet.includes(upperChar)) {\n      return false;\n    }\n  }\n  return true;\n}\nimport.meta.vitest?.test(\"isBase32\", ({ expect }) => {\n  expect(isBase32(\"0123456789ABCDEFGHJKMNPQRSTVWXYZ\")).toBe(true);\n  expect(isBase32(\"0OIJ\")).toBe(false); // O and I are not allowed\n  expect(isBase32(\"ABC DEF\")).toBe(true); // Spaces are allowed\n  expect(isBase32(\"ABC!\")).toBe(false); // Special characters not allowed\n  expect(isBase32(\"\")).toBe(true);\n});\n\nexport function isBase64(input: string): boolean {\n  // This regex allows for standard base64 with proper padding\n  const regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;\n  return regex.test(input);\n}\nimport.meta.vitest?.test(\"isBase64\", ({ expect }) => {\n  expect(isBase64(\"SGVsbG8gV29ybGQ=\")).toBe(true);\n  expect(isBase64(\"SGVsbG8gV29ybGQ\")).toBe(false); // No padding\n  expect(isBase64(\"SGVsbG8gV29ybGQ==\")).toBe(false); // Wrong padding\n  expect(isBase64(\"SGVsbG8!V29ybGQ=\")).toBe(false); // Invalid character\n  expect(isBase64(\"\")).toBe(true);\n});\n\nexport function isBase64Url(input: string): boolean {\n  if (input === \"\") {\n    return true;\n  }\n  const regex = /^[0-9a-zA-Z_-]+$/;\n  return regex.test(input);\n}\nimport.meta.vitest?.test(\"isBase64Url\", ({ expect }) => {\n  expect(isBase64Url(\"SGVsbG8gV2 9ybGQ\")).toBe(false); // Space is not valid\n  expect(isBase64Url(\"SGVsbG8_V29ybGQ\")).toBe(true); // _ is a valid character\n  expect(isBase64Url(\"SGVsbG8-V29ybGQ\")).toBe(true); // - is valid\n  expect(isBase64Url(\"SGVsbG8_V29ybGQ=\")).toBe(false); // = not allowed\n  expect(isBase64Url(\"\")).toBe(true); // Empty string is valid\n});\n"],"mappings":"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"}

package/dist/esm/utils/caches.d.ts

@@ -1,4 +1,4 @@
-import { RateLimitOptions, ReactPromise } from "./promises";
+import { RateLimitOptions, ReactPromise } from "./promises.js";
 
 //#region src/utils/caches.d.ts
 /**

package/dist/esm/utils/caches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"caches.d.ts","names":[],"sources":["../../../src/utils/caches.tsx"],"mappings":";;;;;AASA;iBAAgB,aAAA,WAAwB,QAAA,CAAA,CAAU,CAAA,EAAG,CAAA,GAAI,CAAA;AAAA,KAwDpD,aAAA;AAAA,cAEQ,UAAA;EAAA,iBAIQ,QAAA;EAAA,iBACA,QAAA;EAAA,iBAJF,IAAA;cAGE,QAAA,GAAW,YAAA,EAAc,CAAA,KAAM,OAAA,CAAQ,CAAA,GACvC,QAAA;IACf,WAAA,IAAe,GAAA,EAAK,CAAA,EAAG,OAAA;IACvB,WAAA,GAAc,IAAA,CAAK,gBAAA;EAAA;EAAA,QAMf,YAAA;EASR,aAAA,CAAc,YAAA,EAAc,CAAA,GAAI,eAAA,CAAgB,CAAA;EAe1C,YAAA,CAAa,SAAA,GAAY,YAAA,EAAc,CAAA,eAAa,OAAA;EAUpD,eAAA,CAAgB,SAAA,GAAY,YAAA,EAAc,CAAA,eAAa,OAAA;EAAA,SAUpD,gBAAA,GAAgB,GAAA,EA1ChB,CAAA;EAAA,SA2CA,WAAA,GAAW,GAAA,EA3CX,CAAA;;;;;;;;;;;;;;;;;WA4CA,SAAA,GAAS,GAAA,EA5CT,CAAA,EAAC,aAAA,EAAA,aAAA,KAAA,YAAA,CAAA,CAAA;EAAA,SA6CD,mBAAA,GAAmB,GAAA,EA7CnB,CAAA,EAAC,KAAA,EAAA,CAAA;EAAA,SA8CD,wBAAA,GAAwB,GAAA,EA9CxB,CAAA,EAAC,KAAA,EAAA,OAAA,CAAA,CAAA,MAAA,YAAA;EAAA,SA+CD,OAAA,GAAO,GAAA,EA/CP,CAAA,KAAC,OAAA;EAAA,SAgDD,UAAA,GAAU,GAAA,EAhDV,CAAA,KAAC,OAAA;EAAA,SAiDD,aAAA,GAAa,GAAA,EAjDb,CAAA,EAAC,QAAA,GAAA,KAAA,EAAA,CAAA,EAAA,QAAA,EAAA,CAAA;;;WAkDD,OAAA,GAAO,GAAA,EAlDP,CAAA;AAAA;AAAA,cAqDL,eAAA;EAAA,iBAWe,QAAA;EAAA,QAVX,MAAA;EAAA,QACA,eAAA;EAAA,QACA,QAAA;EAAA,iBACS,iBAAA;EAAA,QACT,mBAAA;EAAA,QACA,cAAA;EAAA,QACA,8BAAA;cAGN,OAAA,QAAe,OAAA,CAAQ,CAAA,GACN,QAAA;IACf,WAAA,IAAe,OAAA;IACf,WAAA,GAAc,IAAA,CAAK,gBAAA;EAAA;EAiBvB,gBAAA,CAAA;EAIA,WAAA,CAAA;;;;;;;;;;;;;;;;;EAIA,SAAA,CAAU,aAAA,EAAe,aAAA,GAAgB,YAAA,CAAa,CAAA;EAAA,QAS9C,IAAA;EAAA,QAIA,SAAA;EAAA,QAWA,QAAA;EAWR,mBAAA,CAAoB,KAAA,EAAO,CAAA;EAI3B,wBAAA,CAAyB,KAAA,EAAO,OAAA,CAAQ,CAAA,IAAK,YAAA;EA3HjB;;;EAkItB,OAAA,CAAA,GAAW,OAAA;EAnHX;;;EA6HA,UAAA,CAAA,GAAc,OAAA;EAMpB,OAAA,CAAA;EAIA,oBAAA,CAAA;EAYA,aAAA,CAAc,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;AAAA"}
+{"version":3,"file":"caches.d.ts","names":[],"sources":["../../../src/utils/caches.tsx"],"mappings":";;;;;AASA;iBAAgB,aAAA,WAAwB,QAAA,EAAU,CAAA,EAAG,CAAA,GAAI,CAAA;AAAA,KAwDpD,aAAA;AAAA,cAEQ,UAAA;EAAA,iBAIQ,QAAA;EAAA,iBACA,QAAA;EAAA,iBAJF,IAAA;cAGE,QAAA,GAAW,YAAA,EAAc,CAAA,KAAM,OAAA,CAAQ,CAAA,GACvC,QAAA;IACf,WAAA,IAAe,GAAA,EAAK,CAAA,EAAG,OAAA;IACvB,WAAA,GAAc,IAAA,CAAK,gBAAA;EAAA;EAAA,QAMf,YAAA;EASR,aAAA,CAAc,YAAA,EAAc,CAAA,GAAI,eAAA,CAAgB,CAAA;EAe1C,YAAA,CAAa,SAAA,GAAY,YAAA,EAAc,CAAA,eAAa,OAAA;EAUpD,eAAA,CAAgB,SAAA,GAAY,YAAA,EAAc,CAAA,eAAa,OAAA;EAAA,SAUpD,gBAAA,GAAgB,GAAA,EA1ChB,CAAA;EAAA,SA2CA,WAAA,GAAW,GAAA,EA3CX,CAAA;;;;;;;;;;;;;;;;;WA4CA,SAAA,GAAS,GAAA,EA5CT,CAAA,EAAC,aAAA,EAAA,aAAA,KAAA,YAAA,CAAA,CAAA;EAAA,SA6CD,mBAAA,GAAmB,GAAA,EA7CnB,CAAA,EAAC,KAAA,EAAA,CAAA;EAAA,SA8CD,wBAAA,GAAwB,GAAA,EA9CxB,CAAA,EAAC,KAAA,EAAA,OAAA,CAAA,CAAA,MAAA,YAAA;EAAA,SA+CD,OAAA,GAAO,GAAA,EA/CP,CAAA,KAAC,OAAA;EAAA,SAgDD,UAAA,GAAU,GAAA,EAhDV,CAAA,KAAC,OAAA;EAAA,SAiDD,aAAA,GAAa,GAAA,EAjDb,CAAA,EAAC,QAAA,GAAA,KAAA,EAAA,CAAA,EAAA,QAAA,EAAA,CAAA;;;WAkDD,OAAA,GAAO,GAAA,EAlDP,CAAA;AAAA;AAAA,cAqDL,eAAA;EAAA,iBAWe,QAAA;EAAA,QAVX,MAAA;EAAA,QACA,eAAA;EAAA,QACA,QAAA;EAAA,iBACS,iBAAA;EAAA,QACT,mBAAA;EAAA,QACA,cAAA;EAAA,QACA,8BAAA;cAGN,OAAA,QAAe,OAAA,CAAQ,CAAA,GACN,QAAA;IACf,WAAA,IAAe,OAAA;IACf,WAAA,GAAc,IAAA,CAAK,gBAAA;EAAA;EAiBvB,gBAAA;EAIA,WAAA;;;;;;;;;;;;;;;;;EAIA,SAAA,CAAU,aAAA,EAAe,aAAA,GAAgB,YAAA,CAAa,CAAA;EAAA,QAS9C,IAAA;EAAA,QAIA,SAAA;EAAA,QAWA,QAAA;EAWR,mBAAA,CAAoB,KAAA,EAAO,CAAA;EAI3B,wBAAA,CAAyB,KAAA,EAAO,OAAA,CAAQ,CAAA,IAAK,YAAA;EA3HjB;;;EAkItB,OAAA,IAAW,OAAA;EAnHX;;;EA6HA,UAAA,IAAc,OAAA;EAMpB,OAAA;EAIA,oBAAA;EAYA,aAAA,CAAc,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;AAAA"}

package/dist/esm/utils/caches.js

@@ -3,7 +3,6 @@ import { DependenciesMap } from "./maps.js";
 import { filterUndefined } from "./objects.js";
 import { pending, rateLimited, resolved, runAsynchronously, wait } from "./promises.js";
 import { AsyncStore } from "./stores.js";
-
 //#region src/utils/caches.tsx
 /**
 * Can be used to cache the result of a function call, for example for the `use` hook in React.
@@ -17,31 +16,6 @@ function cacheFunction(f) {
 		return value;
 	});
 }
-(void 0)?.test("cacheFunction", ({ expect }) => {
-	let callCount = 0;
-	const add = (a, b) => {
-		callCount++;
-		return a + b;
-	};
-	const cachedAdd = cacheFunction(add);
-	expect(cachedAdd(1, 2)).toBe(3);
-	expect(callCount).toBe(1);
-	expect(cachedAdd(1, 2)).toBe(3);
-	expect(callCount).toBe(1);
-	expect(cachedAdd(2, 3)).toBe(5);
-	expect(callCount).toBe(2);
-	let objectCallCount = 0;
-	const createObject = (id) => {
-		objectCallCount++;
-		return { id };
-	};
-	const cachedCreateObject = cacheFunction(createObject);
-	const obj1 = cachedCreateObject(1);
-	expect(obj1).toEqual({ id: 1 });
-	expect(objectCallCount).toBe(1);
-	expect(cachedCreateObject(1)).toBe(obj1);
-	expect(objectCallCount).toBe(1);
-});
 var AsyncCache = class {
 	constructor(_fetcher, _options = {}) {
 		this._fetcher = _fetcher;
@@ -179,7 +153,7 @@ var AsyncValueCache = class {
 		} };
 	}
 };
-
 //#endregion
 export { AsyncCache, cacheFunction };
+
 //# sourceMappingURL=caches.js.map