yummies 7.19.4 → 7.20.1

package/id.d.ts

@@ -1,39 +1,3 @@
-/**
- * ---header-docs-section---
- * # yummies/id
- *
- * ## Description
- *
- * Fast, URL-friendly identifiers based on **nanoid** with curated alphabets and lengths. Use for
- * client-generated keys, trace ids, or UI instance ids where UUID size is unnecessary. Collisions are
- * unlikely at these lengths but still assume server-side uniqueness for persisted entities.
- *
- * ## Usage
- *
- * ```ts
- * import { generateId } from "yummies/id";
- * ```
- */
-/**
- * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
- * Length: 6.
- */
-declare const generateId: (size?: number) => string;
-/**
- * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
- * Length: 4.
- */
-declare const generateShortId: (size?: number) => string;
-/**
- * Uses the alphabet `0123456789`.
- * Length: 6.
- */
-declare const generateNumericId: (size?: number) => string;
-/**
- * Uses the alphabet `0123456789`.
- * Length: 4.
- */
-declare const generateNumericShortId: (size?: number) => string;
 /**
  * Creates a function that generates unique strings based on call order.
  *
@@ -54,6 +18,7 @@ declare const generateNumericShortId: (size?: number) => string;
  * @returns {()=>string}
  */
 declare const createLinearNumericIdGenerator: (size?: number) => () => string;
+
 /**
  *
  * @example
@@ -70,6 +35,7 @@ declare const createLinearNumericIdGenerator: (size?: number) => () => string;
  *
  */
 declare const generateLinearNumericId: () => string;
+
 /**
  * Is not recommended to use.
  *
@@ -77,4 +43,29 @@ declare const generateLinearNumericId: () => string;
  */
 declare const generateStackBasedId: () => string;
 
+/**
+ * @internal Separate chunk so nanoid is tree-shaken away when generateId/generateShortId/etc.
+ * are not used. Consumers import from `yummies/id` — this module is not a public entry point.
+ */
+/**
+ * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
+ * Length: 6.
+ */
+declare const generateId: (size?: number) => string;
+/**
+ * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
+ * Length: 4.
+ */
+declare const generateShortId: (size?: number) => string;
+/**
+ * Uses the alphabet `0123456789`.
+ * Length: 6.
+ */
+declare const generateNumericId: (size?: number) => string;
+/**
+ * Uses the alphabet `0123456789`.
+ * Length: 4.
+ */
+declare const generateNumericShortId: (size?: number) => string;
+
 export { createLinearNumericIdGenerator, generateId, generateLinearNumericId, generateNumericId, generateNumericShortId, generateShortId, generateStackBasedId };

package/id.js

@@ -1,43 +1,5 @@
-import { customAlphabet } from "nanoid";
-//#region src/id.ts
-/**
-* ---header-docs-section---
-* # yummies/id
-*
-* ## Description
-*
-* Fast, URL-friendly identifiers based on **nanoid** with curated alphabets and lengths. Use for
-* client-generated keys, trace ids, or UI instance ids where UUID size is unnecessary. Collisions are
-* unlikely at these lengths but still assume server-side uniqueness for persisted entities.
-*
-* ## Usage
-*
-* ```ts
-* import { generateId } from "yummies/id";
-* ```
-*/
-var DIGITS = "0123456789";
-var ALPHABET = `abcdefghijklmnopqrstuvwxyz${DIGITS}`;
-/**
-* Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
-* Length: 6.
-*/
-var generateId = customAlphabet(ALPHABET, 6);
-/**
-* Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
-* Length: 4.
-*/
-var generateShortId = customAlphabet(ALPHABET, 4);
-/**
-* Uses the alphabet `0123456789`.
-* Length: 6.
-*/
-var generateNumericId = customAlphabet(DIGITS, 6);
-/**
-* Uses the alphabet `0123456789`.
-* Length: 4.
-*/
-var generateNumericShortId = customAlphabet(DIGITS, 4);
+import { generateId, generateNumericId, generateNumericShortId, generateShortId } from "./id-nanoid.js";
+//#region src/id/create-linear-numeric-id-generator.ts
 /**
 * Creates a function that generates unique strings based on call order.
 *
@@ -63,6 +25,8 @@ var createLinearNumericIdGenerator = (size = 9) => {
 		return (lastCount++).toString().padStart(size, "0");
 	};
 };
+//#endregion
+//#region src/id/generate-linear-numeric-id.ts
 /**
 *
 * @example
@@ -79,6 +43,8 @@ var createLinearNumericIdGenerator = (size = 9) => {
 *
 */
 var generateLinearNumericId = createLinearNumericIdGenerator();
+//#endregion
+//#region src/id/generate-stack-based-id.ts
 /**
 * Is not recommended to use.
 *

package/id.js.map

@@ -1 +1 @@
-{"version":3,"file":"id.js","names":[],"sources":["../src/id.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/id\n *\n * ## Description\n *\n * Fast, URL-friendly identifiers based on **nanoid** with curated alphabets and lengths. Use for\n * client-generated keys, trace ids, or UI instance ids where UUID size is unnecessary. Collisions are\n * unlikely at these lengths but still assume server-side uniqueness for persisted entities.\n *\n * ## Usage\n *\n * ```ts\n * import { generateId } from \"yummies/id\";\n * ```\n */\n\nimport { customAlphabet } from 'nanoid';\n\nconst DIGITS = '0123456789';\nconst LATIN_CHARS = 'abcdefghijklmnopqrstuvwxyz';\n\nconst ALPHABET = `${LATIN_CHARS}${DIGITS}`;\n\n/**\n * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.\n * Length: 6.\n */\nexport const generateId = customAlphabet(ALPHABET, 6);\n\n/**\n * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.\n * Length: 4.\n */\nexport const generateShortId = customAlphabet(ALPHABET, 4);\n\n/**\n * Uses the alphabet `0123456789`.\n * Length: 6.\n */\nexport const generateNumericId = customAlphabet(DIGITS, 6);\n\n/**\n * Uses the alphabet `0123456789`.\n * Length: 4.\n */\nexport const generateNumericShortId = customAlphabet(DIGITS, 4);\n\n/**\n * Creates a function that generates unique strings based on call order.\n *\n * @example\n * ```ts\n * generateLinearNumericId = createLinearNumericIdGenerator(6);\n * generateLinearNumericId() // '000000'\n * generateLinearNumericId() // '000001'\n * ...\n * generateLinearNumericId() // '999999'\n * generateLinearNumericId() // '1000000'\n * ...\n * generateLinearNumericId() // '9999999'\n * generateLinearNumericId() // '10000000'\n * ```\n *\n * @param size Minimum string length.\n * @returns {()=>string}\n */\nexport const createLinearNumericIdGenerator = (size: number = 9) => {\n  let lastCount = 0;\n  return () => {\n    return (lastCount++).toString().padStart(size, '0');\n  };\n};\n\n/**\n *\n * @example\n * ```ts\n * generateLinearNumericId() // '000000000'\n * generateLinearNumericId() // '000000001'\n * ...\n * generateLinearNumericId() // '999999999'\n * generateLinearNumericId() // '1000000000'\n * ...\n * generateLinearNumericId() // '9999999999'\n * generateLinearNumericId() // '10000000000'\n * ```\n *\n */\nexport const generateLinearNumericId = createLinearNumericIdGenerator();\n\n/**\n * Is not recommended to use.\n *\n * Generates execution stack based pseudo-id (just sliced string from error stack)\n */\nexport const generateStackBasedId = () =>\n  new Error().stack!.split('\\n').slice(1, 4).join('');\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAM,SAAS;AAGf,IAAM,WAAW,6BAAiB;;;;;AAMlC,IAAa,aAAa,eAAe,UAAU,EAAE;;;;;AAMrD,IAAa,kBAAkB,eAAe,UAAU,EAAE;;;;;AAM1D,IAAa,oBAAoB,eAAe,QAAQ,EAAE;;;;;AAM1D,IAAa,yBAAyB,eAAe,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;AAqB/D,IAAa,kCAAkC,OAAe,MAAM;CAClE,IAAI,YAAY;AAChB,cAAa;AACX,UAAQ,aAAa,UAAU,CAAC,SAAS,MAAM,IAAI;;;;;;;;;;;;;;;;;;AAmBvD,IAAa,0BAA0B,gCAAgC;;;;;;AAOvE,IAAa,8CACX,IAAI,OAAO,EAAC,MAAO,MAAM,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG"}
+{"version":3,"file":"id.js","names":[],"sources":["../src/id/create-linear-numeric-id-generator.ts","../src/id/generate-linear-numeric-id.ts","../src/id/generate-stack-based-id.ts"],"sourcesContent":["/**\n * Creates a function that generates unique strings based on call order.\n *\n * @example\n * ```ts\n * generateLinearNumericId = createLinearNumericIdGenerator(6);\n * generateLinearNumericId() // '000000'\n * generateLinearNumericId() // '000001'\n * ...\n * generateLinearNumericId() // '999999'\n * generateLinearNumericId() // '1000000'\n * ...\n * generateLinearNumericId() // '9999999'\n * generateLinearNumericId() // '10000000'\n * ```\n *\n * @param size Minimum string length.\n * @returns {()=>string}\n */\nexport const createLinearNumericIdGenerator = (size: number = 9) => {\n  let lastCount = 0;\n  return () => {\n    return (lastCount++).toString().padStart(size, '0');\n  };\n};\n","import { createLinearNumericIdGenerator } from './create-linear-numeric-id-generator.js';\n\n/**\n *\n * @example\n * ```ts\n * generateLinearNumericId() // '000000000'\n * generateLinearNumericId() // '000000001'\n * ...\n * generateLinearNumericId() // '999999999'\n * generateLinearNumericId() // '1000000000'\n * ...\n * generateLinearNumericId() // '9999999999'\n * generateLinearNumericId() // '10000000000'\n * ```\n *\n */\nexport const generateLinearNumericId = createLinearNumericIdGenerator();\n","/**\n * Is not recommended to use.\n *\n * Generates execution stack based pseudo-id (just sliced string from error stack)\n */\nexport const generateStackBasedId = () =>\n  new Error().stack!.split('\\n').slice(1, 4).join('');\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,IAAa,kCAAkC,OAAe,MAAM;CAClE,IAAI,YAAY;CAChB,aAAa;EACX,QAAQ,aAAa,SAAS,EAAE,SAAS,MAAM,GAAG;CACpD;AACF;;;;;;;;;;;;;;;;;;ACPA,IAAa,0BAA0B,+BAA+B;;;;;;;;ACZtE,IAAa,8CACX,IAAI,MAAM,GAAE,MAAO,MAAM,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE"}

package/imports.cjs

@@ -1,23 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./chunk-CZWwpsFl.cjs");
 let yummies_async = require("yummies/async");
-//#region src/imports.ts
-/**
-* ---header-docs-section---
-* # yummies/imports
-*
-* ## Description
-*
-* Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM
-* shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,
-* and resilient loading when the network or CDN flakes without freezing the whole app.
-*
-* ## Usage
-*
-* ```ts
-* import { fetchLazyModule } from "yummies/imports";
-* ```
-*/
+//#region src/imports/fetch-lazy-module.ts
 /**
 * Lazily loads a module with retry support.
 *
@@ -39,6 +22,8 @@ var fetchLazyModule = async (fetchModule, attempts = 3, delay = 1e3) => {
 	}
 	throw lastError;
 };
+//#endregion
+//#region src/imports/unpack-async-module.ts
 /**
 * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.
 *

package/imports.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"imports.cjs","names":[],"sources":["../src/imports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/imports\n *\n * ## Description\n *\n * Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM\n * shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,\n * and resilient loading when the network or CDN flakes without freezing the whole app.\n *\n * ## Usage\n *\n * ```ts\n * import { fetchLazyModule } from \"yummies/imports\";\n * ```\n */\n\nimport { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n\nexport type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\n/**\n * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.\n *\n * @example\n * ```ts\n * const component = await unpackAsyncModule(import('./Component.ts'));\n * ```\n */\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;CACf,MAAM,gBAAgB,MAAM,KAAyB,EACnD,QAAQ,UACT,CAAC,CAAC,KAAK,YAAY;CAEpB,IAAI,YAA0B;AAE9B,YAAW,MAAM,WAAW,cAC1B,KAAI;AACF,MAAI,cAAc,KAChB,QAAA,GAAA,cAAA,OAAY,MAAM;AAEpB,SAAO,MAAM,SAAS;UACf,OAAO;AACd,cAAY;;AAGhB,OAAM;;;;;;;;;;AAaR,IAAa,oBAAoB,OAC/B,gBACe;AACf,KAAI,uBAAuB,SAAS;EAClC,MAAM,OAAQ,MAAM;AAEpB,MAAK,KAAa,QAChB,QAAQ,KAAa;MAErB,QAAO;;AAIX,QAAO"}
+{"version":3,"file":"imports.cjs","names":[],"sources":["../src/imports/fetch-lazy-module.ts","../src/imports/unpack-async-module.ts"],"sourcesContent":["import { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n","export type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\n/**\n * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.\n *\n * @example\n * ```ts\n * const component = await unpackAsyncModule(import('./Component.ts'));\n * ```\n */\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"mappings":";;;;;;;;;;;;;AAYA,IAAa,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;CACf,MAAM,gBAAgB,MAAM,KAAyB,EACnD,QAAQ,SACV,CAAC,EAAE,KAAK,WAAW;CAEnB,IAAI,YAA0B;CAE9B,WAAW,MAAM,WAAW,eAC1B,IAAI;EACF,IAAI,cAAc,MAChB,OAAA,GAAA,cAAA,OAAY,KAAK;EAEnB,OAAO,MAAM,QAAQ;CACvB,SAAS,OAAO;EACd,YAAY;CACd;CAEF,MAAM;AACR;;;;;;;;;;;ACxBA,IAAa,oBAAoB,OAC/B,gBACe;CACf,IAAI,uBAAuB,SAAS;EAClC,MAAM,OAAQ,MAAM;EAEpB,IAAK,KAAa,SAChB,OAAQ,KAAa;OAErB,OAAO;CAEX;CAEA,OAAO;AACT"}

package/imports.d.ts

@@ -1,19 +1,3 @@
-/**
- * ---header-docs-section---
- * # yummies/imports
- *
- * ## Description
- *
- * Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM
- * shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,
- * and resilient loading when the network or CDN flakes without freezing the whole app.
- *
- * ## Usage
- *
- * ```ts
- * import { fetchLazyModule } from "yummies/imports";
- * ```
- */
 /**
  * Lazily loads a module with retry support.
  *
@@ -25,6 +9,7 @@
  * ```
  */
 declare const fetchLazyModule: <T>(fetchModule: () => Promise<T>, attempts?: number, delay?: number) => Promise<T>;
+
 type PackedAsyncModule<T> = Promise<T | {
     default: T;
 }>;

package/imports.js

@@ -1,21 +1,5 @@
 import { sleep } from "yummies/async";
-//#region src/imports.ts
-/**
-* ---header-docs-section---
-* # yummies/imports
-*
-* ## Description
-*
-* Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM
-* shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,
-* and resilient loading when the network or CDN flakes without freezing the whole app.
-*
-* ## Usage
-*
-* ```ts
-* import { fetchLazyModule } from "yummies/imports";
-* ```
-*/
+//#region src/imports/fetch-lazy-module.ts
 /**
 * Lazily loads a module with retry support.
 *
@@ -37,6 +21,8 @@ var fetchLazyModule = async (fetchModule, attempts = 3, delay = 1e3) => {
 	}
 	throw lastError;
 };
+//#endregion
+//#region src/imports/unpack-async-module.ts
 /**
 * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.
 *

package/imports.js.map

@@ -1 +1 @@
-{"version":3,"file":"imports.js","names":[],"sources":["../src/imports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/imports\n *\n * ## Description\n *\n * Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM\n * shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,\n * and resilient loading when the network or CDN flakes without freezing the whole app.\n *\n * ## Usage\n *\n * ```ts\n * import { fetchLazyModule } from \"yummies/imports\";\n * ```\n */\n\nimport { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n\nexport type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\n/**\n * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.\n *\n * @example\n * ```ts\n * const component = await unpackAsyncModule(import('./Component.ts'));\n * ```\n */\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;CACf,MAAM,gBAAgB,MAAM,KAAyB,EACnD,QAAQ,UACT,CAAC,CAAC,KAAK,YAAY;CAEpB,IAAI,YAA0B;AAE9B,YAAW,MAAM,WAAW,cAC1B,KAAI;AACF,MAAI,cAAc,KAChB,OAAM,MAAM,MAAM;AAEpB,SAAO,MAAM,SAAS;UACf,OAAO;AACd,cAAY;;AAGhB,OAAM;;;;;;;;;;AAaR,IAAa,oBAAoB,OAC/B,gBACe;AACf,KAAI,uBAAuB,SAAS;EAClC,MAAM,OAAQ,MAAM;AAEpB,MAAK,KAAa,QAChB,QAAQ,KAAa;MAErB,QAAO;;AAIX,QAAO"}
+{"version":3,"file":"imports.js","names":[],"sources":["../src/imports/fetch-lazy-module.ts","../src/imports/unpack-async-module.ts"],"sourcesContent":["import { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n","export type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\n/**\n * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.\n *\n * @example\n * ```ts\n * const component = await unpackAsyncModule(import('./Component.ts'));\n * ```\n */\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"mappings":";;;;;;;;;;;;AAYA,IAAa,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;CACf,MAAM,gBAAgB,MAAM,KAAyB,EACnD,QAAQ,SACV,CAAC,EAAE,KAAK,WAAW;CAEnB,IAAI,YAA0B;CAE9B,WAAW,MAAM,WAAW,eAC1B,IAAI;EACF,IAAI,cAAc,MAChB,MAAM,MAAM,KAAK;EAEnB,OAAO,MAAM,QAAQ;CACvB,SAAS,OAAO;EACd,YAAY;CACd;CAEF,MAAM;AACR;;;;;;;;;;;ACxBA,IAAa,oBAAoB,OAC/B,gBACe;CACf,IAAI,uBAAuB,SAAS;EAClC,MAAM,OAAQ,MAAM;EAEpB,IAAK,KAAa,SAChB,OAAQ,KAAa;OAErB,OAAO;CAEX;CAEA,OAAO;AACT"}

package/math.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/math.ts
+//#region src/math/deg-to-rad.ts
 /**
 * Converts degrees to radians.
 *
@@ -11,17 +11,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function degToRad(deg) {
 	return deg * (Math.PI / 180);
 }
-/**
-* Converts radians to degrees.
-*
-* @example
-* ```ts
-* radToDeg(Math.PI); // 180
-* ```
-*/
-function radToDeg(rad) {
-	return rad * (180 / Math.PI);
-}
+//#endregion
+//#region src/math/percent-from.ts
 /**
 * Returns what percentage `value` is of `from`.
 * @example
@@ -34,6 +25,19 @@ var percentFrom = (value, from) => {
 	return (value ?? 0) / (from ?? 0) * 100 || 0;
 };
 //#endregion
+//#region src/math/rad-to-deg.ts
+/**
+* Converts radians to degrees.
+*
+* @example
+* ```ts
+* radToDeg(Math.PI); // 180
+* ```
+*/
+function radToDeg(rad) {
+	return rad * (180 / Math.PI);
+}
+//#endregion
 exports.degToRad = degToRad;
 exports.percentFrom = percentFrom;
 exports.radToDeg = radToDeg;

package/math.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"math.cjs","names":[],"sources":["../src/math.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/math\n *\n * ## Description\n *\n * Tiny math helpers: degree/radian conversion and nullable-safe percentage calculations. They wrap\n * common formulas so components do not repeat magic numbers or null checks when deriving layout or\n * charts from partially loaded data.\n *\n * ## Usage\n *\n * ```ts\n * import { degToRad, percentFrom } from \"yummies/math\";\n * ```\n */\n\nimport type { Maybe } from 'yummies/types';\n\n/**\n * Converts degrees to radians.\n *\n * @example\n * ```ts\n * degToRad(180); // Math.PI\n * ```\n */\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\n\n/**\n * Converts radians to degrees.\n *\n * @example\n * ```ts\n * radToDeg(Math.PI); // 180\n * ```\n */\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n"],"mappings":";;;;;;;;;;AA2BA,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,KAAK,KAAK;;;;;;;;;;AAW1B,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,MAAM,KAAK;;;;;;;;;;AAW3B,IAAa,eAAe,OAAsB,SAAwB;AACxE,SAAS,SAAS,MAAM,QAAQ,KAAM,OAAO"}
+{"version":3,"file":"math.cjs","names":[],"sources":["../src/math/deg-to-rad.ts","../src/math/percent-from.ts","../src/math/rad-to-deg.ts"],"sourcesContent":["/**\n * Converts degrees to radians.\n *\n * @example\n * ```ts\n * degToRad(180); // Math.PI\n * ```\n */\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\n","import type { Maybe } from 'yummies/types';\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n","/**\n * Converts radians to degrees.\n *\n * @example\n * ```ts\n * radToDeg(Math.PI); // 180\n * ```\n */\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgB,SAAS,KAAa;CACpC,OAAO,OAAO,KAAK,KAAK;AAC1B;;;;;;;;;;;ACAA,IAAa,eAAe,OAAsB,SAAwB;CACxE,QAAS,SAAS,MAAM,QAAQ,KAAM,OAAO;AAC/C;;;;;;;;;;;ACJA,SAAgB,SAAS,KAAa;CACpC,OAAO,OAAO,MAAM,KAAK;AAC3B"}

package/math.d.ts

@@ -1,31 +1,25 @@
 import { Maybe } from 'yummies/types';
 
 /**
- * ---header-docs-section---
- * # yummies/math
- *
- * ## Description
- *
- * Tiny math helpers: degree/radian conversion and nullable-safe percentage calculations. They wrap
- * common formulas so components do not repeat magic numbers or null checks when deriving layout or
- * charts from partially loaded data.
- *
- * ## Usage
+ * Converts degrees to radians.
  *
+ * @example
  * ```ts
- * import { degToRad, percentFrom } from "yummies/math";
+ * degToRad(180); // Math.PI
  * ```
  */
+declare function degToRad(deg: number): number;
 
 /**
- * Converts degrees to radians.
- *
+ * Returns what percentage `value` is of `from`.
  * @example
  * ```ts
- * degToRad(180); // Math.PI
+ * percentFrom(500, 2000) // 25
+ * percentFrom(1000, 2000) // 50
  * ```
  */
-declare function degToRad(deg: number): number;
+declare const percentFrom: (value: Maybe<number>, from: Maybe<number>) => number;
+
 /**
  * Converts radians to degrees.
  *
@@ -35,14 +29,5 @@ declare function degToRad(deg: number): number;
  * ```
  */
 declare function radToDeg(rad: number): number;
-/**
- * Returns what percentage `value` is of `from`.
- * @example
- * ```ts
- * percentFrom(500, 2000) // 25
- * percentFrom(1000, 2000) // 50
- * ```
- */
-declare const percentFrom: (value: Maybe<number>, from: Maybe<number>) => number;
 
 export { degToRad, percentFrom, radToDeg };

package/math.js

@@ -1,4 +1,4 @@
-//#region src/math.ts
+//#region src/math/deg-to-rad.ts
 /**
 * Converts degrees to radians.
 *
@@ -10,17 +10,8 @@
 function degToRad(deg) {
 	return deg * (Math.PI / 180);
 }
-/**
-* Converts radians to degrees.
-*
-* @example
-* ```ts
-* radToDeg(Math.PI); // 180
-* ```
-*/
-function radToDeg(rad) {
-	return rad * (180 / Math.PI);
-}
+//#endregion
+//#region src/math/percent-from.ts
 /**
 * Returns what percentage `value` is of `from`.
 * @example
@@ -33,6 +24,19 @@ var percentFrom = (value, from) => {
 	return (value ?? 0) / (from ?? 0) * 100 || 0;
 };
 //#endregion
+//#region src/math/rad-to-deg.ts
+/**
+* Converts radians to degrees.
+*
+* @example
+* ```ts
+* radToDeg(Math.PI); // 180
+* ```
+*/
+function radToDeg(rad) {
+	return rad * (180 / Math.PI);
+}
+//#endregion
 export { degToRad, percentFrom, radToDeg };
 
 //# sourceMappingURL=math.js.map

package/math.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.js","names":[],"sources":["../src/math.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/math\n *\n * ## Description\n *\n * Tiny math helpers: degree/radian conversion and nullable-safe percentage calculations. They wrap\n * common formulas so components do not repeat magic numbers or null checks when deriving layout or\n * charts from partially loaded data.\n *\n * ## Usage\n *\n * ```ts\n * import { degToRad, percentFrom } from \"yummies/math\";\n * ```\n */\n\nimport type { Maybe } from 'yummies/types';\n\n/**\n * Converts degrees to radians.\n *\n * @example\n * ```ts\n * degToRad(180); // Math.PI\n * ```\n */\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\n\n/**\n * Converts radians to degrees.\n *\n * @example\n * ```ts\n * radToDeg(Math.PI); // 180\n * ```\n */\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n"],"mappings":";;;;;;;;;AA2BA,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,KAAK,KAAK;;;;;;;;;;AAW1B,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,MAAM,KAAK;;;;;;;;;;AAW3B,IAAa,eAAe,OAAsB,SAAwB;AACxE,SAAS,SAAS,MAAM,QAAQ,KAAM,OAAO"}
+{"version":3,"file":"math.js","names":[],"sources":["../src/math/deg-to-rad.ts","../src/math/percent-from.ts","../src/math/rad-to-deg.ts"],"sourcesContent":["/**\n * Converts degrees to radians.\n *\n * @example\n * ```ts\n * degToRad(180); // Math.PI\n * ```\n */\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\n","import type { Maybe } from 'yummies/types';\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n","/**\n * Converts radians to degrees.\n *\n * @example\n * ```ts\n * radToDeg(Math.PI); // 180\n * ```\n */\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,SAAS,KAAa;CACpC,OAAO,OAAO,KAAK,KAAK;AAC1B;;;;;;;;;;;ACAA,IAAa,eAAe,OAAsB,SAAwB;CACxE,QAAS,SAAS,MAAM,QAAQ,KAAM,OAAO;AAC/C;;;;;;;;;;;ACJA,SAAgB,SAAS,KAAa;CACpC,OAAO,OAAO,MAAM,KAAK;AAC3B"}