@stackframe/stack-shared 2.8.7 → 2.8.10

package/dist/utils/api-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/api-keys.tsx"],"sourcesContent":["import crc32 from 'crc/crc32';\nimport { getBase32CharacterFromIndex } from \"./bytes\";\nimport { generateSecureRandomString } from \"./crypto\";\nimport { StackAssertionError } from \"./errors\";\n\n\nconst STACK_AUTH_MARKER = \"574ck4u7h\";\n\n// API key part lengths\nconst API_KEY_LENGTHS = {\n  SECRET_PART: 45,\n  ID_PART: 32,\n  TYPE_PART: 4,\n  SCANNER: 1,\n  MARKER: 9,\n  CHECKSUM: 8,\n} as const;\n\n/**\n * An api key has the following format:\n * <prefix_without_underscores>_<secret_part_45_chars><id_part_32_chars><type_user_or_team_4_chars><scanner_and_marker_10_chars><checksum_8_chars>\n *\n * The scanner and marker is a base32 character that is used to determine if the api key is a public or private key\n * and if it is a cloud or self-hosted key.\n *\n * The checksum is a crc32 checksum of the api key encoded in hex.\n *\n */\n\ntype ProjectApiKey = {\n  id: string,\n  prefix: string,\n  isPublic: boolean,\n  isCloudVersion: boolean,\n  secret: string,\n  checksum: string,\n  type: \"user\" | \"team\",\n}\n\n\nfunction createChecksumSync(checksummablePart: string): string {\n  const data = new TextEncoder().encode(checksummablePart);\n  const calculated_checksum = crc32(data);\n  return calculated_checksum.toString(16).padStart(8, \"0\");\n}\n\nfunction createApiKeyParts(options: Pick<ProjectApiKey, \"id\" | \"isPublic\" | \"isCloudVersion\" | \"type\">) {\n  const { id, isPublic, isCloudVersion, type } = options;\n  const prefix = isPublic ? \"pk\" : \"sk\";\n  const scannerFlag = (isCloudVersion ? 0 : 1) + (isPublic ? 2 : 0) + (/* version */ 0);\n\n  const secretPart = generateSecureRandomString();\n  const idPart = id.replace(/-/g, \"\");\n  const scannerAndMarker = getBase32CharacterFromIndex(scannerFlag).toLowerCase() + STACK_AUTH_MARKER;\n  const checksummablePart = `${prefix}_${secretPart}${idPart}${type}${scannerAndMarker}`;\n\n  return { checksummablePart, idPart, prefix, scannerAndMarker, type };\n}\n\n\nfunction parseApiKeyParts(secret: string) {\n  const regex = new RegExp(\n    `^([a-zA-Z0-9_]+)_` + // prefix\n    `([a-zA-Z0-9_]{${API_KEY_LENGTHS.SECRET_PART}})` + // secretPart\n    `([a-zA-Z0-9_]{${API_KEY_LENGTHS.ID_PART}})` + // idPart\n    `([a-zA-Z0-9_]{${API_KEY_LENGTHS.TYPE_PART}})` + // type\n    `([a-zA-Z0-9_]{${API_KEY_LENGTHS.SCANNER}})` + // scanner\n    `(${STACK_AUTH_MARKER})` + // marker\n    `([a-zA-Z0-9_]{${API_KEY_LENGTHS.CHECKSUM}})$` // checksum\n  );\n\n  const match = secret.match(regex);\n  if (!match) {\n    throw new StackAssertionError(\"Invalid API key format\");\n  }\n\n  const [, prefix, secretPart, idPart, type, scannerFlag, marker, checksum] = match;\n\n  const isCloudVersion = parseInt(scannerFlag, 32) % 2 === 0;\n  const isPublic = (parseInt(scannerFlag, 32) & 2) !== 0;\n\n  const checksummablePart = `${prefix}_${secretPart}${idPart}${type}${scannerFlag}${marker}`;\n  const restored_id = idPart.replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, \"$1-$2-$3-$4-$5\");\n\n  if (![\"user\", \"team\"].includes(type)) {\n    throw new StackAssertionError(\"Invalid type\");\n  }\n\n  return { checksummablePart, checksum, id: restored_id, isCloudVersion, isPublic, prefix, type: type as \"user\" | \"team\" };\n}\n\n\nexport function isApiKey(secret: string): boolean {\n  return secret.includes(\"_\") && secret.includes(STACK_AUTH_MARKER);\n}\n\nexport function createProjectApiKey(options: Pick<ProjectApiKey, \"id\" | \"isPublic\" | \"isCloudVersion\" | \"type\">): string {\n  const { checksummablePart } = createApiKeyParts(options);\n  const checksum = createChecksumSync(checksummablePart);\n  return `${checksummablePart}${checksum}`;\n}\n\n\nexport function parseProjectApiKey(secret: string): ProjectApiKey {\n  const { checksummablePart, checksum, id, isCloudVersion, isPublic, prefix, type } = parseApiKeyParts(secret);\n  const calculated_checksum = createChecksumSync(checksummablePart);\n\n  if (calculated_checksum !== checksum) {\n    throw new StackAssertionError(\"Checksum mismatch\");\n  }\n\n  return {\n    id,\n    prefix,\n    isPublic,\n    isCloudVersion,\n    secret,\n    checksum,\n    type,\n  };\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAClB,mBAA4C;AAC5C,oBAA2C;AAC3C,oBAAoC;AAGpC,IAAM,oBAAoB;AAG1B,IAAM,kBAAkB;AAAA,EACtB,aAAa;AAAA,EACb,SAAS;AAAA,EACT,WAAW;AAAA,EACX,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,UAAU;AACZ;AAwBA,SAAS,mBAAmB,mBAAmC;AAC7D,QAAM,OAAO,IAAI,YAAY,EAAE,OAAO,iBAAiB;AACvD,QAAM,0BAAsB,aAAAA,SAAM,IAAI;AACtC,SAAO,oBAAoB,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AACzD;AAEA,SAAS,kBAAkB,SAA6E;AACtG,QAAM,EAAE,IAAI,UAAU,gBAAgB,KAAK,IAAI;AAC/C,QAAM,SAAS,WAAW,OAAO;AACjC,QAAM,eAAe,iBAAiB,IAAI,MAAM,WAAW,IAAI;AAAA,EAAoB;AAEnF,QAAM,iBAAa,0CAA2B;AAC9C,QAAM,SAAS,GAAG,QAAQ,MAAM,EAAE;AAClC,QAAM,uBAAmB,0CAA4B,WAAW,EAAE,YAAY,IAAI;AAClF,QAAM,oBAAoB,GAAG,MAAM,IAAI,UAAU,GAAG,MAAM,GAAG,IAAI,GAAG,gBAAgB;AAEpF,SAAO,EAAE,mBAAmB,QAAQ,QAAQ,kBAAkB,KAAK;AACrE;AAGA,SAAS,iBAAiB,QAAgB;AACxC,QAAM,QAAQ,IAAI;AAAA,IAChB,kCACiB,gBAAgB,WAAW,mBAC3B,gBAAgB,OAAO,mBACvB,gBAAgB,SAAS,mBACzB,gBAAgB,OAAO,MACpC,iBAAiB,kBACJ,gBAAgB,QAAQ;AAAA;AAAA,EAC3C;AAEA,QAAM,QAAQ,OAAO,MAAM,KAAK;AAChC,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,kCAAoB,wBAAwB;AAAA,EACxD;AAEA,QAAM,CAAC,EAAE,QAAQ,YAAY,QAAQ,MAAM,aAAa,QAAQ,QAAQ,IAAI;AAE5E,QAAM,iBAAiB,SAAS,aAAa,EAAE,IAAI,MAAM;AACzD,QAAM,YAAY,SAAS,aAAa,EAAE,IAAI,OAAO;AAErD,QAAM,oBAAoB,GAAG,MAAM,IAAI,UAAU,GAAG,MAAM,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM;AACxF,QAAM,cAAc,OAAO,QAAQ,mCAAmC,gBAAgB;AAEtF,MAAI,CAAC,CAAC,QAAQ,MAAM,EAAE,SAAS,IAAI,GAAG;AACpC,UAAM,IAAI,kCAAoB,cAAc;AAAA,EAC9C;AAEA,SAAO,EAAE,mBAAmB,UAAU,IAAI,aAAa,gBAAgB,UAAU,QAAQ,KAA8B;AACzH;AAGO,SAAS,SAAS,QAAyB;AAChD,SAAO,OAAO,SAAS,GAAG,KAAK,OAAO,SAAS,iBAAiB;AAClE;AAEO,SAAS,oBAAoB,SAAqF;AACvH,QAAM,EAAE,kBAAkB,IAAI,kBAAkB,OAAO;AACvD,QAAM,WAAW,mBAAmB,iBAAiB;AACrD,SAAO,GAAG,iBAAiB,GAAG,QAAQ;AACxC;AAGO,SAAS,mBAAmB,QAA+B;AAChE,QAAM,EAAE,mBAAmB,UAAU,IAAI,gBAAgB,UAAU,QAAQ,KAAK,IAAI,iBAAiB,MAAM;AAC3G,QAAM,sBAAsB,mBAAmB,iBAAiB;AAEhE,MAAI,wBAAwB,UAAU;AACpC,UAAM,IAAI,kCAAoB,mBAAmB;AAAA,EACnD;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":["crc32"]}

package/dist/utils/arrays.d.cts

@@ -0,0 +1,18 @@
+declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
+declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
+declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
+/**
+ * Ponyfill for ES2023's findLastIndex.
+ */
+declare function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number;
+declare function groupBy<T extends any, K>(arr: Iterable<T>, key: (item: T) => K): Map<K, T[]>;
+declare function range(endExclusive: number): number[];
+declare function range(startInclusive: number, endExclusive: number): number[];
+declare function range(startInclusive: number, endExclusive: number, step: number): number[];
+declare function rotateLeft(arr: readonly any[], n: number): any[];
+declare function rotateRight(arr: readonly any[], n: number): any[];
+declare function shuffle<T>(arr: readonly T[]): T[];
+declare function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][];
+declare function unique<T>(arr: readonly T[]): T[];
+
+export { enumerate, findLastIndex, groupBy, isShallowEqual, outerProduct, range, rotateLeft, rotateRight, shuffle, typedIncludes, unique };

package/dist/utils/arrays.d.ts

@@ -1,16 +1,18 @@
-export declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
-export declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
-export declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
+declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
+declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
+declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
 /**
  * Ponyfill for ES2023's findLastIndex.
  */
-export declare function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number;
-export declare function groupBy<T extends any, K>(arr: Iterable<T>, key: (item: T) => K): Map<K, T[]>;
-export declare function range(endExclusive: number): number[];
-export declare function range(startInclusive: number, endExclusive: number): number[];
-export declare function range(startInclusive: number, endExclusive: number, step: number): number[];
-export declare function rotateLeft(arr: readonly any[], n: number): any[];
-export declare function rotateRight(arr: readonly any[], n: number): any[];
-export declare function shuffle<T>(arr: readonly T[]): T[];
-export declare function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][];
-export declare function unique<T>(arr: readonly T[]): T[];
+declare function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number;
+declare function groupBy<T extends any, K>(arr: Iterable<T>, key: (item: T) => K): Map<K, T[]>;
+declare function range(endExclusive: number): number[];
+declare function range(startInclusive: number, endExclusive: number): number[];
+declare function range(startInclusive: number, endExclusive: number, step: number): number[];
+declare function rotateLeft(arr: readonly any[], n: number): any[];
+declare function rotateRight(arr: readonly any[], n: number): any[];
+declare function shuffle<T>(arr: readonly T[]): T[];
+declare function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][];
+declare function unique<T>(arr: readonly T[]): T[];
+
+export { enumerate, findLastIndex, groupBy, isShallowEqual, outerProduct, range, rotateLeft, rotateRight, shuffle, typedIncludes, unique };

package/dist/utils/arrays.js

@@ -1,180 +1,113 @@
-import { remainder } from "./math";
-export function typedIncludes(arr, item) {
-    return arr.includes(item);
-}
-import.meta.vitest?.test("typedIncludes", ({ expect }) => {
-    const arr = [1, 2, 3];
-    expect(typedIncludes(arr, 1)).toBe(true);
-    expect(typedIncludes(arr, 4)).toBe(false);
-    expect(typedIncludes(arr, "1")).toBe(false);
-    const strArr = ["a", "b", "c"];
-    expect(typedIncludes(strArr, "a")).toBe(true);
-    expect(typedIncludes(strArr, "d")).toBe(false);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/arrays.tsx
+var arrays_exports = {};
+__export(arrays_exports, {
+  enumerate: () => enumerate,
+  findLastIndex: () => findLastIndex,
+  groupBy: () => groupBy,
+  isShallowEqual: () => isShallowEqual,
+  outerProduct: () => outerProduct,
+  range: () => range,
+  rotateLeft: () => rotateLeft,
+  rotateRight: () => rotateRight,
+  shuffle: () => shuffle,
+  typedIncludes: () => typedIncludes,
+  unique: () => unique
 });
-export function enumerate(arr) {
-    return arr.map((item, index) => [index, item]);
+module.exports = __toCommonJS(arrays_exports);
+var import_math = require("./math");
+function typedIncludes(arr, item) {
+  return arr.includes(item);
 }
-import.meta.vitest?.test("enumerate", ({ expect }) => {
-    expect(enumerate([])).toEqual([]);
-    expect(enumerate([1, 2, 3])).toEqual([[0, 1], [1, 2], [2, 3]]);
-    expect(enumerate(["a", "b", "c"])).toEqual([[0, "a"], [1, "b"], [2, "c"]]);
-});
-export function isShallowEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
+function enumerate(arr) {
+  return arr.map((item, index) => [index, item]);
 }
-import.meta.vitest?.test("isShallowEqual", ({ expect }) => {
-    expect(isShallowEqual([], [])).toBe(true);
-    expect(isShallowEqual([1, 2, 3], [1, 2, 3])).toBe(true);
-    expect(isShallowEqual([1, 2, 3], [1, 2, 4])).toBe(false);
-    expect(isShallowEqual([1, 2, 3], [1, 2])).toBe(false);
-    expect(isShallowEqual([1, 2], [1, 2, 3])).toBe(false);
-    // Test with objects (reference equality)
-    const obj1 = { a: 1 };
-    const obj2 = { a: 1 };
-    expect(isShallowEqual([obj1], [obj1])).toBe(true);
-    expect(isShallowEqual([obj1], [obj2])).toBe(false);
-});
-/**
- * Ponyfill for ES2023's findLastIndex.
- */
-export function findLastIndex(arr, predicate) {
-    for (let i = arr.length - 1; i >= 0; i--) {
-        if (predicate(arr[i]))
-            return i;
-    }
-    return -1;
+function isShallowEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
 }
-import.meta.vitest?.test("findLastIndex", ({ expect }) => {
-    expect(findLastIndex([], () => true)).toBe(-1);
-    expect(findLastIndex([1, 2, 3, 4, 5], x => x % 2 === 0)).toBe(3); // 4 is at index 3
-    expect(findLastIndex([1, 2, 3, 4, 5], x => x > 10)).toBe(-1);
-    expect(findLastIndex([1, 2, 3, 2, 1], x => x === 2)).toBe(3);
-    expect(findLastIndex([1, 2, 3], x => x === 1)).toBe(0);
-});
-export function groupBy(arr, key) {
-    const result = new Map;
-    for (const item of arr) {
-        const k = key(item);
-        if (result.get(k) === undefined)
-            result.set(k, []);
-        result.get(k).push(item);
-    }
-    return result;
+function findLastIndex(arr, predicate) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i])) return i;
+  }
+  return -1;
 }
-import.meta.vitest?.test("groupBy", ({ expect }) => {
-    expect(groupBy([], (x) => x)).toEqual(new Map());
-    const numbers = [1, 2, 3, 4, 5, 6];
-    const grouped = groupBy(numbers, (n) => n % 2 === 0 ? "even" : "odd");
-    expect(grouped.get("even")).toEqual([2, 4, 6]);
-    expect(grouped.get("odd")).toEqual([1, 3, 5]);
-    // Check the actual lengths of the words to ensure our test is correct
-    const words = ["apple", "banana", "cherry", "date", "elderberry"];
-    const byLength = groupBy(words, (w) => w.length);
-    // Adjust expectations based on actual word lengths
-    expect(byLength.get(5)).toEqual(["apple"]);
-    expect(byLength.get(6)).toEqual(["banana", "cherry"]);
-    expect(byLength.get(4)).toEqual(["date"]);
-    expect(byLength.get(10)).toEqual(["elderberry"]);
-});
-export function range(startInclusive, endExclusive, step) {
-    if (endExclusive === undefined) {
-        endExclusive = startInclusive;
-        startInclusive = 0;
-    }
-    if (step === undefined)
-        step = 1;
-    const result = [];
-    for (let i = startInclusive; step > 0 ? (i < endExclusive) : (i > endExclusive); i += step) {
-        result.push(i);
-    }
-    return result;
+function groupBy(arr, key) {
+  const result = /* @__PURE__ */ new Map();
+  for (const item of arr) {
+    const k = key(item);
+    if (result.get(k) === void 0) result.set(k, []);
+    result.get(k).push(item);
+  }
+  return result;
 }
-import.meta.vitest?.test("range", ({ expect }) => {
-    expect(range(5)).toEqual([0, 1, 2, 3, 4]);
-    expect(range(2, 5)).toEqual([2, 3, 4]);
-    expect(range(1, 10, 2)).toEqual([1, 3, 5, 7, 9]);
-    expect(range(5, 0, -1)).toEqual([5, 4, 3, 2, 1]);
-    expect(range(0, 0)).toEqual([]);
-    expect(range(0, 10, 3)).toEqual([0, 3, 6, 9]);
-});
-export function rotateLeft(arr, n) {
-    if (arr.length === 0)
-        return [];
-    const index = remainder(n, arr.length);
-    return [...arr.slice(index), ...arr.slice(0, index)];
+function range(startInclusive, endExclusive, step) {
+  if (endExclusive === void 0) {
+    endExclusive = startInclusive;
+    startInclusive = 0;
+  }
+  if (step === void 0) step = 1;
+  const result = [];
+  for (let i = startInclusive; step > 0 ? i < endExclusive : i > endExclusive; i += step) {
+    result.push(i);
+  }
+  return result;
 }
-import.meta.vitest?.test("rotateLeft", ({ expect }) => {
-    expect(rotateLeft([], 1)).toEqual([]);
-    expect(rotateLeft([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);
-    expect(rotateLeft([1, 2, 3, 4, 5], 1)).toEqual([2, 3, 4, 5, 1]);
-    expect(rotateLeft([1, 2, 3, 4, 5], 3)).toEqual([4, 5, 1, 2, 3]);
-    expect(rotateLeft([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);
-    expect(rotateLeft([1, 2, 3, 4, 5], 6)).toEqual([2, 3, 4, 5, 1]);
-});
-export function rotateRight(arr, n) {
-    return rotateLeft(arr, -n);
+function rotateLeft(arr, n) {
+  if (arr.length === 0) return [];
+  const index = (0, import_math.remainder)(n, arr.length);
+  return [...arr.slice(index), ...arr.slice(0, index)];
 }
-import.meta.vitest?.test("rotateRight", ({ expect }) => {
-    expect(rotateRight([], 1)).toEqual([]);
-    expect(rotateRight([1, 2, 3, 4, 5], 0)).toEqual([1, 2, 3, 4, 5]);
-    expect(rotateRight([1, 2, 3, 4, 5], 1)).toEqual([5, 1, 2, 3, 4]);
-    expect(rotateRight([1, 2, 3, 4, 5], 3)).toEqual([3, 4, 5, 1, 2]);
-    expect(rotateRight([1, 2, 3, 4, 5], 5)).toEqual([1, 2, 3, 4, 5]);
-    expect(rotateRight([1, 2, 3, 4, 5], 6)).toEqual([5, 1, 2, 3, 4]);
-});
-export function shuffle(arr) {
-    const result = [...arr];
-    for (let i = result.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        [result[i], result[j]] = [result[j], result[i]];
-    }
-    return result;
+function rotateRight(arr, n) {
+  return rotateLeft(arr, -n);
 }
-import.meta.vitest?.test("shuffle", ({ expect }) => {
-    // Test empty array
-    expect(shuffle([])).toEqual([]);
-    // Test single element array
-    expect(shuffle([1])).toEqual([1]);
-    // Test that shuffle returns a new array
-    const original = [1, 2, 3, 4, 5];
-    const shuffled = shuffle(original);
-    expect(shuffled).not.toBe(original);
-    // Test that all elements are preserved
-    expect(shuffled.sort((a, b) => a - b)).toEqual(original);
-    // Test with a larger array to ensure randomness
-    // This is a probabilistic test, but it's very unlikely to fail
-    const large = Array.from({ length: 100 }, (_, i) => i);
-    const shuffledLarge = shuffle(large);
-    expect(shuffledLarge).not.toEqual(large);
-    expect(shuffledLarge.sort((a, b) => a - b)).toEqual(large);
-});
-export function outerProduct(arr1, arr2) {
-    return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2]));
+function shuffle(arr) {
+  const result = [...arr];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
 }
-import.meta.vitest?.test("outerProduct", ({ expect }) => {
-    expect(outerProduct([], [])).toEqual([]);
-    expect(outerProduct([1], [])).toEqual([]);
-    expect(outerProduct([], [1])).toEqual([]);
-    expect(outerProduct([1], [2])).toEqual([[1, 2]]);
-    expect(outerProduct([1, 2], [3, 4])).toEqual([[1, 3], [1, 4], [2, 3], [2, 4]]);
-    expect(outerProduct(["a", "b"], [1, 2])).toEqual([["a", 1], ["a", 2], ["b", 1], ["b", 2]]);
-});
-export function unique(arr) {
-    return [...new Set(arr)];
+function outerProduct(arr1, arr2) {
+  return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2]));
+}
+function unique(arr) {
+  return [...new Set(arr)];
 }
-import.meta.vitest?.test("unique", ({ expect }) => {
-    expect(unique([])).toEqual([]);
-    expect(unique([1, 2, 3])).toEqual([1, 2, 3]);
-    expect(unique([1, 2, 2, 3, 1, 3])).toEqual([1, 2, 3]);
-    // Test with objects (reference equality)
-    const obj = { a: 1 };
-    expect(unique([obj, obj])).toEqual([obj]);
-    // Test with different types
-    expect(unique([1, "1", true, 1, "1", true])).toEqual([1, "1", true]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enumerate,
+  findLastIndex,
+  groupBy,
+  isShallowEqual,
+  outerProduct,
+  range,
+  rotateLeft,
+  rotateRight,
+  shuffle,
+  typedIncludes,
+  unique
 });
+//# sourceMappingURL=arrays.js.map

package/dist/utils/arrays.js.map

@@ -0,0 +1 @@
+{"version":3,"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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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}\nundefined?.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"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA0B;AAEnB,SAAS,cAAwC,KAAQ,MAAkC;AAChG,SAAO,IAAI,SAAS,IAAI;AAC1B;AAYO,SAAS,UAAoC,KAA+B;AACjF,SAAO,IAAI,IAAI,CAAC,MAAM,UAAU,CAAC,OAAO,IAAI,CAAC;AAC/C;AAOO,SAAS,eAAe,GAAmB,GAA4B;AAC5E,MAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,QAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAG,QAAO;AAAA,EAC5B;AACA,SAAO;AACT;AAiBO,SAAS,cAAiB,KAAmB,WAAyC;AAC3F,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,QAAI,UAAU,IAAI,CAAC,CAAC,EAAG,QAAO;AAAA,EAChC;AACA,SAAO;AACT;AASO,SAAS,QACd,KACA,KACa;AACb,QAAM,SAAS,oBAAI;AACnB,aAAW,QAAQ,KAAK;AACtB,UAAM,IAAI,IAAI,IAAI;AAClB,QAAI,OAAO,IAAI,CAAC,MAAM,OAAW,QAAO,IAAI,GAAG,CAAC,CAAC;AACjD,WAAO,IAAI,CAAC,EAAG,KAAK,IAAI;AAAA,EAC1B;AACA,SAAO;AACT;AAuBO,SAAS,MAAM,gBAAwB,cAAuB,MAAyB;AAC5F,MAAI,iBAAiB,QAAW;AAC9B,mBAAe;AACf,qBAAiB;AAAA,EACnB;AACA,MAAI,SAAS,OAAW,QAAO;AAE/B,QAAM,SAAS,CAAC;AAChB,WAAS,IAAI,gBAAgB,OAAO,IAAK,IAAI,eAAiB,IAAI,cAAe,KAAK,MAAM;AAC1F,WAAO,KAAK,CAAC;AAAA,EACf;AACA,SAAO;AACT;AAWO,SAAS,WAAW,KAAqB,GAAkB;AAChE,MAAI,IAAI,WAAW,EAAG,QAAO,CAAC;AAC9B,QAAM,YAAQ,uBAAU,GAAG,IAAI,MAAM;AACrC,SAAO,CAAC,GAAG,IAAI,MAAM,KAAK,GAAG,GAAG,IAAI,MAAM,GAAG,KAAK,CAAC;AACrD;AAUO,SAAS,YAAY,KAAqB,GAAkB;AACjE,SAAO,WAAW,KAAK,CAAC,CAAC;AAC3B;AAWO,SAAS,QAAW,KAAwB;AACjD,QAAM,SAAS,CAAC,GAAG,GAAG;AACtB,WAAS,IAAI,OAAO,SAAS,GAAG,IAAI,GAAG,KAAK;AAC1C,UAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;AAC5C,KAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,EAChD;AACA,SAAO;AACT;AAyBO,SAAS,aAAmB,MAAoB,MAA8B;AACnF,SAAO,KAAK,QAAQ,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,CAAC,OAAO,KAAK,CAAW,CAAC;AAC9E;AAUO,SAAS,OAAU,KAAwB;AAChD,SAAO,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC;AACzB;","names":[]}

package/dist/utils/base64.d.cts

@@ -0,0 +1,4 @@
+declare function fileToBase64(file: File): Promise<string>;
+declare function validateBase64Image(base64: string): boolean;
+
+export { fileToBase64, validateBase64Image };

package/dist/utils/base64.d.ts

@@ -1,2 +1,4 @@
-export declare function fileToBase64(file: File): Promise<string>;
-export declare function validateBase64Image(base64: string): boolean;
+declare function fileToBase64(file: File): Promise<string>;
+declare function validateBase64Image(base64: string): boolean;
+
+export { fileToBase64, validateBase64Image };

package/dist/utils/base64.js

@@ -1,23 +1,44 @@
-export function fileToBase64(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.readAsDataURL(file);
-        reader.onload = () => resolve(reader.result);
-        reader.onerror = error => reject(error);
-    });
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/base64.tsx
+var base64_exports = {};
+__export(base64_exports, {
+  fileToBase64: () => fileToBase64,
+  validateBase64Image: () => validateBase64Image
+});
+module.exports = __toCommonJS(base64_exports);
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = (error) => reject(error);
+  });
 }
-export function validateBase64Image(base64) {
-    const base64ImageRegex = /^data:image\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/;
-    return base64ImageRegex.test(base64);
+function validateBase64Image(base64) {
+  const base64ImageRegex = /^data:image\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/;
+  return base64ImageRegex.test(base64);
 }
-import.meta.vitest?.test("validateBase64Image", ({ expect }) => {
-    // Valid base64 image strings
-    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);
-    // Invalid base64 image strings
-    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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileToBase64,
+  validateBase64Image
 });
+//# sourceMappingURL=base64.js.map

package/dist/utils/base64.js.map

@@ -0,0 +1 @@
+{"version":3,"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}\nundefined?.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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,aAAa,MAA6B;AACxD,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,SAAS,IAAI,WAAW;AAC9B,WAAO,cAAc,IAAI;AACzB,WAAO,SAAS,MAAM,QAAQ,OAAO,MAAgB;AACrD,WAAO,UAAU,WAAS,OAAO,KAAK;AAAA,EACxC,CAAC;AACH;AAEO,SAAS,oBAAoB,QAAyB;AAC3D,QAAM,mBAAmB;AACzB,SAAO,iBAAiB,KAAK,MAAM;AACrC;","names":[]}

package/dist/utils/booleans.d.cts

@@ -0,0 +1,6 @@
+type Truthy<T> = T extends null | undefined | 0 | "" | false ? false : true;
+type Falsy<T> = T extends null | undefined | 0 | "" | false ? true : false;
+declare function isTruthy<T>(value: T): value is T & Truthy<T>;
+declare function isFalsy<T>(value: T): value is T & Falsy<T>;
+
+export { type Falsy, type Truthy, isFalsy, isTruthy };

package/dist/utils/booleans.d.ts

@@ -1,4 +1,6 @@
-export type Truthy<T> = T extends null | undefined | 0 | "" | false ? false : true;
-export type Falsy<T> = T extends null | undefined | 0 | "" | false ? true : false;
-export declare function isTruthy<T>(value: T): value is T & Truthy<T>;
-export declare function isFalsy<T>(value: T): value is T & Falsy<T>;
+type Truthy<T> = T extends null | undefined | 0 | "" | false ? false : true;
+type Falsy<T> = T extends null | undefined | 0 | "" | false ? true : false;
+declare function isTruthy<T>(value: T): value is T & Truthy<T>;
+declare function isFalsy<T>(value: T): value is T & Falsy<T>;
+
+export { type Falsy, type Truthy, isFalsy, isTruthy };

package/dist/utils/booleans.js

@@ -1,30 +1,38 @@
-export function isTruthy(value) {
-    return !!value;
-}
-import.meta.vitest?.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(undefined)).toBe(false);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/booleans.tsx
+var booleans_exports = {};
+__export(booleans_exports, {
+  isFalsy: () => isFalsy,
+  isTruthy: () => isTruthy
 });
-export function isFalsy(value) {
-    return !value;
+module.exports = __toCommonJS(booleans_exports);
+function isTruthy(value) {
+  return !!value;
+}
+function isFalsy(value) {
+  return !value;
 }
-import.meta.vitest?.test("isFalsy", ({ expect }) => {
-    expect(isFalsy(false)).toBe(true);
-    expect(isFalsy(0)).toBe(true);
-    expect(isFalsy("")).toBe(true);
-    expect(isFalsy(null)).toBe(true);
-    expect(isFalsy(undefined)).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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFalsy,
+  isTruthy
 });
+//# sourceMappingURL=booleans.js.map

package/dist/utils/booleans.js.map

@@ -0,0 +1 @@
+{"version":3,"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}\nundefined?.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}\nundefined?.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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,SAAY,OAAkC;AAC5D,SAAO,CAAC,CAAC;AACX;AAcO,SAAS,QAAW,OAAiC;AAC1D,SAAO,CAAC;AACV;","names":[]}

package/dist/utils/browser-compat.d.cts

@@ -0,0 +1,8 @@
+declare function getBrowserCompatibilityReport(): {
+    optionalChaining: string | boolean;
+    nullishCoalescing: string | boolean;
+    weakRef: string | boolean;
+    cryptoUuid: string | boolean;
+};
+
+export { getBrowserCompatibilityReport };

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

@@ -1,6 +1,8 @@
-export declare function getBrowserCompatibilityReport(): {
+declare function getBrowserCompatibilityReport(): {
     optionalChaining: string | boolean;
     nullishCoalescing: string | boolean;
     weakRef: string | boolean;
     cryptoUuid: string | boolean;
 };
+
+export { getBrowserCompatibilityReport };