yummies 7.19.3 → 7.20.0

package/assert.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_chunk = require("./chunk-CZWwpsFl.cjs");
+const require_chunk = require("./chunk-DakpK96I.cjs");
 let yummies_type_guard = require("yummies/type-guard");
 let yummies_common = require("yummies/common");
 //#region src/assert/_exports.ts

package/assert.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"assert.cjs","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject, Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function object<T extends AnyObject = AnyObject>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isObject(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an object'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function array<T extends any[] = any[]>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isArray(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an array'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,SAAA,GAAA,eAAA,cAAoB,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,mBAAA,UAAU,QAAQ,UAAU,CAC9B,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,CAAC,mBAAA,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,mBAAA,UAAU,OAAO,MAAM,CACzB,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,mBAAA,UAAU,YAAY,MAAM,CAC9B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACoB;AACpB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,MACd,OACA,SACoB;AACpB,KAAI,CAAC,mBAAA,UAAU,QAAQ,MAAM,CAC3B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SAC0B;AAC1B,KAAI,CAAC,mBAAA,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}
+{"version":3,"file":"assert.cjs","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject, Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function object<T extends AnyObject = AnyObject>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isObject(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an object'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function array<T extends any[] = any[]>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isArray(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an array'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;AAClB;AAEA,SAAS,qBACP,SACA,UACQ;CACR,IAAI,YAAY,KAAA,GACd,OAAO;CAET,QAAA,GAAA,eAAA,cAAoB,OAAO;AAC7B;;;;;;;;;;;;AAaA,SAAgB,GACd,WACA,SACmB;CACnB,IAAI,mBAAA,UAAU,QAAQ,SAAS,GAC7B,MAAM,IAAI,eAAe,qBAAqB,SAAS,kBAAkB,CAAC;AAE9E;;;;AAKA,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;CACjC,IAAI,CAAC,mBAAA,UAAU,UAAU,KAAK,GAC5B,MAAM,IAAI,eACR,qBAAqB,SAAS,0BAA0B,CAC1D;AAEJ;;;;;;;AAQA,SAAgB,QACd,OACA,SACoB;CACpB,IAAI,mBAAA,UAAU,OAAO,KAAK,GACxB,MAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC3D;AAEJ;;;;;;;AAQA,SAAgB,aACd,OACA,SACoB;CACpB,IAAI,mBAAA,UAAU,YAAY,KAAK,GAC7B,MAAM,IAAI,eACR,qBAAqB,SAAS,0BAA0B,CAC1D;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACyB;CACzB,IAAI,CAAC,mBAAA,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,mBAAmB,CACnD;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACoB;CACpB,IAAI,CAAC,mBAAA,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACpD;AAEJ;;;;;;;AAQA,SAAgB,MACd,OACA,SACoB;CACpB,IAAI,CAAC,mBAAA,UAAU,QAAQ,KAAK,GAC1B,MAAM,IAAI,eACR,qBAAqB,SAAS,mBAAmB,CACnD;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACyB;CACzB,IAAI,CAAC,mBAAA,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,0BAA0B,CAC1D;AAEJ;;;;;;;AAQA,SAAgB,QACd,OACA,SAC0B;CAC1B,IAAI,CAAC,mBAAA,UAAU,UAAU,KAAK,GAC5B,MAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACpD;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACyB;CACzB,IAAI,CAAC,mBAAA,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,mBAAmB,CACnD;AAEJ;;;;;;;;;;;;;;;AAgBA,SAAgB,KAAK,SAAkC;CACrD,MAAM,IAAI,eAAe,qBAAqB,SAAS,aAAa,CAAC;AACvE;;;;;;;AAQA,SAAgB,YAAY,OAAc,SAAyB;CACjE,MAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,KAAK,GAAG,CACpE;AACF;;;;;;;;;;;;;AAmBA,SAAgB,WACd,OACA,MACA,SACoB;CACpB,IAAI,EAAE,iBAAiB,OACrB,MAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,MAAM,CACnE;AAEJ"}

package/assert.js

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./chunk-pbuEa-1d.js";
+import { t as __exportAll } from "./chunk-D7D4PA-g.js";
 import { typeGuard } from "yummies/type-guard";
 import { callFunction } from "yummies/common";
 //#region src/assert/_exports.ts

package/assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"assert.js","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject, Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function object<T extends AnyObject = AnyObject>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isObject(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an object'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function array<T extends any[] = any[]>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isArray(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an array'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,QAAO,aAAa,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,UAAU,QAAQ,UAAU,CAC9B,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,CAAC,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,OAAO,MAAM,CACzB,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,YAAY,MAAM,CAC9B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACoB;AACpB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,MACd,OACA,SACoB;AACpB,KAAI,CAAC,UAAU,QAAQ,MAAM,CAC3B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SAC0B;AAC1B,KAAI,CAAC,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}
+{"version":3,"file":"assert.js","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject, Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function object<T extends AnyObject = AnyObject>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isObject(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an object'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function array<T extends any[] = any[]>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isArray(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an array'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;AAClB;AAEA,SAAS,qBACP,SACA,UACQ;CACR,IAAI,YAAY,KAAA,GACd,OAAO;CAET,OAAO,aAAa,OAAO;AAC7B;;;;;;;;;;;;AAaA,SAAgB,GACd,WACA,SACmB;CACnB,IAAI,UAAU,QAAQ,SAAS,GAC7B,MAAM,IAAI,eAAe,qBAAqB,SAAS,kBAAkB,CAAC;AAE9E;;;;AAKA,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;CACjC,IAAI,CAAC,UAAU,UAAU,KAAK,GAC5B,MAAM,IAAI,eACR,qBAAqB,SAAS,0BAA0B,CAC1D;AAEJ;;;;;;;AAQA,SAAgB,QACd,OACA,SACoB;CACpB,IAAI,UAAU,OAAO,KAAK,GACxB,MAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC3D;AAEJ;;;;;;;AAQA,SAAgB,aACd,OACA,SACoB;CACpB,IAAI,UAAU,YAAY,KAAK,GAC7B,MAAM,IAAI,eACR,qBAAqB,SAAS,0BAA0B,CAC1D;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACyB;CACzB,IAAI,CAAC,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,mBAAmB,CACnD;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACoB;CACpB,IAAI,CAAC,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACpD;AAEJ;;;;;;;AAQA,SAAgB,MACd,OACA,SACoB;CACpB,IAAI,CAAC,UAAU,QAAQ,KAAK,GAC1B,MAAM,IAAI,eACR,qBAAqB,SAAS,mBAAmB,CACnD;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACyB;CACzB,IAAI,CAAC,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,0BAA0B,CAC1D;AAEJ;;;;;;;AAQA,SAAgB,QACd,OACA,SAC0B;CAC1B,IAAI,CAAC,UAAU,UAAU,KAAK,GAC5B,MAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACpD;AAEJ;;;;;;;AAQA,SAAgB,OACd,OACA,SACyB;CACzB,IAAI,CAAC,UAAU,SAAS,KAAK,GAC3B,MAAM,IAAI,eACR,qBAAqB,SAAS,mBAAmB,CACnD;AAEJ;;;;;;;;;;;;;;;AAgBA,SAAgB,KAAK,SAAkC;CACrD,MAAM,IAAI,eAAe,qBAAqB,SAAS,aAAa,CAAC;AACvE;;;;;;;AAQA,SAAgB,YAAY,OAAc,SAAyB;CACjE,MAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,KAAK,GAAG,CACpE;AACF;;;;;;;;;;;;;AAmBA,SAAgB,WACd,OACA,MACA,SACoB;CACpB,IAAI,EAAE,iBAAiB,OACrB,MAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,MAAM,CACnE;AAEJ"}

package/async.cjs

@@ -1,56 +1,93 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/async.ts
+//#region src/async/async-template.ts
 /**
-* Returns a promise that resolves after `time` milliseconds.
+* Tagged template that builds an async iterable of string chunks (like a streaming template engine).
 *
-* When `signal` is passed and becomes aborted before the delay elapses, the promise
-* rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).
-* The timeout is cleared on abort so no resolve happens after cancellation.
+* Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,
+* a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a
+* **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).
 *
-* @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).
-* @param signal - Optional `AbortSignal` to cancel the wait early.
-* @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.
+* Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
+* becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks
+* with `for await...of` or utilities like `Array.fromAsync` where available.
+*
+* @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).
+* @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).
+* @returns An async generator yielding string fragments in document order.
 *
 * @example
-* Basic pause in an async function:
+* Plain values and promises:
 * ```ts
-* await sleep(250);
-* console.log('after 250ms');
+* const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;
+* let out = '';
+* for await (const chunk of gen) out += chunk;
+* // out === 'Hello, world! Status: 200'
 * ```
 *
 * @example
-* Cancellable delay tied to component unmount or user action:
+* Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
 * ```ts
-* const ac = new AbortController();
-* try {
-*   await sleep(5000, ac.signal);
-* } catch (e) {
-*   // aborted — e is signal.reason
+* const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;
+* const out = await Array.fromAsync(gen).then((parts) => parts.join(''));
+* // out === 'ABC'
+* ```
+*
+* @example
+* Stream from an async iterable (e.g. chunked upstream text):
+* ```ts
+* async function* lines() {
+*   yield 'line1\n';
+*   yield 'line2\n';
 * }
-* ac.abort('user cancelled');
+* const gen = asyncTemplate`Header\n${lines()}Footer`;
+* ```
+*
+* @example
+* Lazy piece via a thunk (invoked as `piece()`):
+* ```ts
+* let n = 0;
+* const gen = asyncTemplate`count=${() => ++n}`;
+* // first consumption yields "count=1", etc.
 * ```
 */
-var sleep = (time = 0, signal) => new Promise((resolve, reject) => {
-	if (signal) {
-		const abortListener = () => {
-			clearTimeout(timerId);
-			reject(signal?.reason);
-		};
-		const timerId = setTimeout(() => {
-			signal.removeEventListener("abort", abortListener);
-			resolve();
-		}, time);
-		signal.addEventListener("abort", abortListener, { once: true });
-	} else setTimeout(resolve, time);
-});
+async function* asyncTemplate(strings, ...pieces) {
+	for (let i = 0; i < strings.length; i++) {
+		yield strings[i];
+		if (i < pieces.length) {
+			const piece = pieces[i];
+			yield* processTemplatePiece(piece);
+		}
+	}
+}
 /**
-* Creates a promise that resolves after the specified number of milliseconds.
+* Resolves a template piece into yielded string chunks.
 *
-* @deprecated Use `sleep` instead.
-* @param ms Delay in milliseconds.
-* @returns Promise
+* Skips output when `value === null || value === undefined || value === false`.
+* Otherwise awaits promises, flattens arrays, streams async iterables, invokes **functions** with no arguments and
+* recurses on the return value, and uses `String(value)` for primitives.
 */
-var waitAsync = async (ms = 1e3) => new Promise((resolve) => setTimeout(resolve, ms));
+async function* processTemplatePiece(piece) {
+	if (piece === null || piece === void 0 || piece === false) return;
+	if (piece instanceof Promise) {
+		yield* processTemplatePiece(await piece);
+		return;
+	}
+	if (Array.isArray(piece)) {
+		for (const item of piece) yield* processTemplatePiece(item);
+		return;
+	}
+	if (typeof piece === "object" && piece !== null && typeof piece[Symbol.asyncIterator] === "function") {
+		for await (const item of piece) yield* processTemplatePiece(item);
+		return;
+	}
+	if (typeof piece === "function") {
+		yield* processTemplatePiece(piece());
+		return;
+	}
+	yield String(piece);
+}
+//#endregion
+//#region src/async/endless-raf.ts
 /**
 * Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.
 * If it returns a truthy value, the loop stops and no further frames are scheduled.
@@ -93,44 +130,8 @@ var endlessRAF = (quitFunction, asMicrotask) => {
 	if (asMicrotask) queueMicrotask(raf);
 	else raf();
 };
-/**
-* Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared
-* and `callback` is never run. If the callback runs normally, the abort listener is removed.
-*
-* Does nothing special if `signal` is omitted — behaves like a plain timeout.
-*
-* @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).
-* @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).
-* @param signal - When aborted, clears the pending timeout so `callback` is not invoked.
-*
-* @example
-* ```ts
-* const controller = new AbortController();
-* setAbortableTimeout(() => console.log('done'), 500, controller.signal);
-* // later: controller.abort(); // timeout cancelled, log never runs
-* ```
-*
-* @example
-* Zero-delay scheduling that can still be cancelled before the macrotask runs:
-* ```ts
-* const ac = new AbortController();
-* setAbortableTimeout(() => startIntro(), 0, ac.signal);
-* // e.g. on teardown: ac.abort();
-* ```
-*/
-function setAbortableTimeout(callback, delayInMs, signal) {
-	let internalTimer = null;
-	const handleAbort = () => {
-		if (internalTimer == null) return;
-		clearTimeout(internalTimer);
-		internalTimer = null;
-	};
-	signal?.addEventListener("abort", handleAbort, { once: true });
-	internalTimer = setTimeout(() => {
-		signal?.removeEventListener("abort", handleAbort);
-		callback();
-	}, delayInMs);
-}
+//#endregion
+//#region src/async/set-abortable-interval.ts
 /**
 * Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`
 * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval
@@ -164,92 +165,101 @@ function setAbortableInterval(callback, delayInMs, signal) {
 	signal?.addEventListener("abort", handleAbort, { once: true });
 	timer = setInterval(callback, delayInMs);
 }
+//#endregion
+//#region src/async/set-abortable-timeout.ts
 /**
-* Tagged template that builds an async iterable of string chunks (like a streaming template engine).
-*
-* Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,
-* a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a
-* **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).
+* Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared
+* and `callback` is never run. If the callback runs normally, the abort listener is removed.
 *
-* Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
-* becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks
-* with `for await...of` or utilities like `Array.fromAsync` where available.
+* Does nothing special if `signal` is omitted — behaves like a plain timeout.
 *
-* @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).
-* @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).
-* @returns An async generator yielding string fragments in document order.
+* @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).
+* @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).
+* @param signal - When aborted, clears the pending timeout so `callback` is not invoked.
 *
 * @example
-* Plain values and promises:
 * ```ts
-* const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;
-* let out = '';
-* for await (const chunk of gen) out += chunk;
-* // out === 'Hello, world! Status: 200'
+* const controller = new AbortController();
+* setAbortableTimeout(() => console.log('done'), 500, controller.signal);
+* // later: controller.abort(); // timeout cancelled, log never runs
 * ```
 *
 * @example
-* Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
+* Zero-delay scheduling that can still be cancelled before the macrotask runs:
 * ```ts
-* const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;
-* const out = await Array.fromAsync(gen).then((parts) => parts.join(''));
-* // out === 'ABC'
+* const ac = new AbortController();
+* setAbortableTimeout(() => startIntro(), 0, ac.signal);
+* // e.g. on teardown: ac.abort();
 * ```
+*/
+function setAbortableTimeout(callback, delayInMs, signal) {
+	let internalTimer = null;
+	const handleAbort = () => {
+		if (internalTimer == null) return;
+		clearTimeout(internalTimer);
+		internalTimer = null;
+	};
+	signal?.addEventListener("abort", handleAbort, { once: true });
+	internalTimer = setTimeout(() => {
+		signal?.removeEventListener("abort", handleAbort);
+		callback();
+	}, delayInMs);
+}
+//#endregion
+//#region src/async/sleep.ts
+/**
+* Returns a promise that resolves after `time` milliseconds.
+*
+* When `signal` is passed and becomes aborted before the delay elapses, the promise
+* rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).
+* The timeout is cleared on abort so no resolve happens after cancellation.
+*
+* @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).
+* @param signal - Optional `AbortSignal` to cancel the wait early.
+* @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.
 *
 * @example
-* Stream from an async iterable (e.g. chunked upstream text):
+* Basic pause in an async function:
 * ```ts
-* async function* lines() {
-*   yield 'line1\n';
-*   yield 'line2\n';
-* }
-* const gen = asyncTemplate`Header\n${lines()}Footer`;
+* await sleep(250);
+* console.log('after 250ms');
 * ```
 *
 * @example
-* Lazy piece via a thunk (invoked as `piece()`):
+* Cancellable delay tied to component unmount or user action:
 * ```ts
-* let n = 0;
-* const gen = asyncTemplate`count=${() => ++n}`;
-* // first consumption yields "count=1", etc.
+* const ac = new AbortController();
+* try {
+*   await sleep(5000, ac.signal);
+* } catch (e) {
+*   // aborted — e is signal.reason
+* }
+* ac.abort('user cancelled');
 * ```
 */
-async function* asyncTemplate(strings, ...pieces) {
-	for (let i = 0; i < strings.length; i++) {
-		yield strings[i];
-		if (i < pieces.length) {
-			const piece = pieces[i];
-			yield* processTemplatePiece(piece);
-		}
-	}
-}
+var sleep = (time = 0, signal) => new Promise((resolve, reject) => {
+	if (signal) {
+		const abortListener = () => {
+			clearTimeout(timerId);
+			reject(signal?.reason);
+		};
+		const timerId = setTimeout(() => {
+			signal.removeEventListener("abort", abortListener);
+			resolve();
+		}, time);
+		signal.addEventListener("abort", abortListener, { once: true });
+	} else setTimeout(resolve, time);
+});
+//#endregion
+//#region src/async/wait-async.ts
 /**
-* Resolves a template piece into yielded string chunks.
+* Creates a promise that resolves after the specified number of milliseconds.
 *
-* Skips output when `value === null || value === undefined || value === false`.
-* Otherwise awaits promises, flattens arrays, streams async iterables, invokes **functions** with no arguments and
-* recurses on the return value, and uses `String(value)` for primitives.
+* @deprecated Use `sleep` instead.
+* @param ms Delay in milliseconds.
+* @returns Promise
 */
-async function* processTemplatePiece(piece) {
-	if (piece === null || piece === void 0 || piece === false) return;
-	if (piece instanceof Promise) {
-		yield* processTemplatePiece(await piece);
-		return;
-	}
-	if (Array.isArray(piece)) {
-		for (const item of piece) yield* processTemplatePiece(item);
-		return;
-	}
-	if (typeof piece === "object" && piece !== null && typeof piece[Symbol.asyncIterator] === "function") {
-		for await (const item of piece) yield* processTemplatePiece(item);
-		return;
-	}
-	if (typeof piece === "function") {
-		yield* processTemplatePiece(piece());
-		return;
-	}
-	yield String(piece);
-}
+var waitAsync = (ms = 1e3) => sleep(ms);
 //#endregion
 exports.asyncTemplate = asyncTemplate;
 exports.endlessRAF = endlessRAF;

package/async.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"async.cjs","names":[],"sources":["../src/async.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/async\n *\n * ## Description\n *\n * Helpers for asynchronous control flow: delays, cancellable waits, scheduling on the next frame,\n * and small utilities around `requestAnimationFrame` and `queueMicrotask`. They complement native\n * `Promise`/`AbortSignal` patterns and keep timing logic easy to test and tree-shake per call site.\n * Import only what you need from `yummies/async` so bundlers can drop unused helpers.\n *\n * ## Usage\n *\n * ```ts\n * import { sleep } from \"yummies/async\";\n * ```\n */\n\nimport type { MaybeFn, MaybePromise, Primitive } from './types.js';\n\n/**\n * Returns a promise that resolves after `time` milliseconds.\n *\n * When `signal` is passed and becomes aborted before the delay elapses, the promise\n * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).\n * The timeout is cleared on abort so no resolve happens after cancellation.\n *\n * @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).\n * @param signal - Optional `AbortSignal` to cancel the wait early.\n * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.\n *\n * @example\n * Basic pause in an async function:\n * ```ts\n * await sleep(250);\n * console.log('after 250ms');\n * ```\n *\n * @example\n * Cancellable delay tied to component unmount or user action:\n * ```ts\n * const ac = new AbortController();\n * try {\n *   await sleep(5000, ac.signal);\n * } catch (e) {\n *   // aborted — e is signal.reason\n * }\n * ac.abort('user cancelled');\n * ```\n */\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n  new Promise<void>((resolve, reject) => {\n    if (signal) {\n      const abortListener = () => {\n        clearTimeout(timerId);\n        reject(signal?.reason);\n      };\n      const timerId = setTimeout(() => {\n        signal.removeEventListener('abort', abortListener);\n        resolve();\n      }, time);\n      signal.addEventListener('abort', abortListener, { once: true });\n    } else {\n      setTimeout(resolve, time);\n    }\n  });\n\n/**\n * Creates a promise that resolves after the specified number of milliseconds.\n *\n * @deprecated Use `sleep` instead.\n * @param ms Delay in milliseconds.\n * @returns Promise\n */\nexport const waitAsync = async (ms = 1000) =>\n  new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.\n * If it returns a truthy value, the loop stops and no further frames are scheduled.\n * If it returns falsy or nothing, the next frame is scheduled recursively.\n *\n * Use this for per-frame work (animations, layout reads after paint) without managing\n * `cancelAnimationFrame` manually — returning `true` from `quitFunction` is the exit condition.\n *\n * When `asMicrotask` is `true`, scheduling the next RAF is deferred with `queueMicrotask`\n * so other microtasks can run before the frame is requested (useful when you need to\n * batch DOM updates or let reactive frameworks flush first).\n *\n * @param quitFunction - Invoked each animation frame. Return `true` to stop the loop.\n * @param asMicrotask - If `true`, wrap the `requestAnimationFrame` call in `queueMicrotask`.\n *\n * @example\n * Stop after 60 frames (~1s at 60Hz):\n * ```ts\n * let frames = 0;\n * endlessRAF(() => {\n *   frames++;\n *   updateSomething(frames);\n *   return frames >= 60;\n * });\n * ```\n *\n * @example\n * Run until an element is removed or a flag is set:\n * ```ts\n * let running = true;\n * endlessRAF(() => {\n *   if (!running || !document.body.contains(el)) return true;\n *   draw(el);\n * }, true);\n * ```\n */\nexport const endlessRAF = (\n  quitFunction: () => boolean | void,\n  asMicrotask?: boolean,\n) => {\n  if (quitFunction()) return;\n\n  const raf = () =>\n    requestAnimationFrame(() => endlessRAF(quitFunction, asMicrotask));\n\n  if (asMicrotask) {\n    queueMicrotask(raf);\n  } else {\n    raf();\n  }\n};\n\n/**\n * Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared\n * and `callback` is never run. If the callback runs normally, the abort listener is removed.\n *\n * Does nothing special if `signal` is omitted — behaves like a plain timeout.\n *\n * @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).\n * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).\n * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableTimeout(() => console.log('done'), 500, controller.signal);\n * // later: controller.abort(); // timeout cancelled, log never runs\n * ```\n *\n * @example\n * Zero-delay scheduling that can still be cancelled before the macrotask runs:\n * ```ts\n * const ac = new AbortController();\n * setAbortableTimeout(() => startIntro(), 0, ac.signal);\n * // e.g. on teardown: ac.abort();\n * ```\n */\nexport function setAbortableTimeout(\n  callback: VoidFunction,\n  delayInMs?: number,\n  signal?: AbortSignal,\n) {\n  let internalTimer: number | null = null;\n\n  const handleAbort = () => {\n    if (internalTimer == null) {\n      return;\n    }\n    clearTimeout(internalTimer);\n    internalTimer = null;\n  };\n\n  signal?.addEventListener('abort', handleAbort, { once: true });\n\n  internalTimer = setTimeout(() => {\n    signal?.removeEventListener('abort', handleAbort);\n    callback();\n  }, delayInMs);\n}\n\n/**\n * Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`\n * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval\n * (you must clear it yourself).\n *\n * @param callback - Invoked every `delayInMs` milliseconds until aborted or cleared.\n * @param delayInMs - Interval period in milliseconds (same as `setInterval`).\n * @param signal - Aborting stops the interval and removes the abort listener path from keeping work alive.\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableInterval(() => console.log('tick'), 1000, controller.signal);\n * // stop: controller.abort();\n * ```\n *\n * @example\n * ```ts\n * const ac = new AbortController();\n * setAbortableInterval(syncStatus, 30_000, ac.signal);\n * window.addEventListener('beforeunload', () => ac.abort());\n * ```\n */\nexport function setAbortableInterval(\n  callback: VoidFunction,\n  delayInMs?: number,\n  signal?: AbortSignal,\n) {\n  let timer: number | null = null;\n\n  const handleAbort = () => {\n    if (timer == null) {\n      return;\n    }\n    clearInterval(timer);\n    timer = null;\n  };\n\n  signal?.addEventListener('abort', handleAbort, { once: true });\n\n  timer = setInterval(callback, delayInMs);\n}\n\n/**\n * A single interpolated segment in {@link asyncTemplate}.\n *\n * - **Primitives** use `String(value)` for output, except that values matching\n *   `value === null || value === undefined || value === false` yield no text (early return in `processTemplatePiece`).\n *   Other falsy values such as `0` or `''` are still stringified.\n * - **Arrays** are flattened recursively in order.\n * - **Promises** are awaited; the resolved value is processed the same way.\n * - **Async iterables of primitives** are streamed in order; each yielded value uses the same rules\n *   as a standalone primitive (`String(...)`, with `null` / `undefined` / `false` omitted).\n * - **Functions** (thunks): if the piece is a function, it is invoked with **no arguments** (`piece()`), and the return\n *   value is processed recursively—so you can defer work or return any other {@link AsyncTemplatePiece} shape\n *   (see {@link MaybeFn}). At runtime a thunk may also return a `Promise` of a piece; that is covered by\n *   {@link MaybePromise} on each template interpolation.\n */\nexport type AsyncTemplatePiece = MaybeFn<\n  | Primitive\n  | void\n  | AsyncIterable<Primitive>\n  | Promise<Primitive>\n  | AsyncTemplatePiece[]\n>;\n\n/**\n * Tagged template that builds an async iterable of string chunks (like a streaming template engine).\n *\n * Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,\n * a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a\n * **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).\n *\n * Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value\n * becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks\n * with `for await...of` or utilities like `Array.fromAsync` where available.\n *\n * @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).\n * @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).\n * @returns An async generator yielding string fragments in document order.\n *\n * @example\n * Plain values and promises:\n * ```ts\n * const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;\n * let out = '';\n * for await (const chunk of gen) out += chunk;\n * // out === 'Hello, world! Status: 200'\n * ```\n *\n * @example\n * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:\n * ```ts\n * const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;\n * const out = await Array.fromAsync(gen).then((parts) => parts.join(''));\n * // out === 'ABC'\n * ```\n *\n * @example\n * Stream from an async iterable (e.g. chunked upstream text):\n * ```ts\n * async function* lines() {\n *   yield 'line1\\n';\n *   yield 'line2\\n';\n * }\n * const gen = asyncTemplate`Header\\n${lines()}Footer`;\n * ```\n *\n * @example\n * Lazy piece via a thunk (invoked as `piece()`):\n * ```ts\n * let n = 0;\n * const gen = asyncTemplate`count=${() => ++n}`;\n * // first consumption yields \"count=1\", etc.\n * ```\n */\nexport async function* asyncTemplate(\n  strings: TemplateStringsArray,\n  ...pieces: MaybePromise<AsyncTemplatePiece>[]\n) {\n  for (let i = 0; i < strings.length; i++) {\n    yield strings[i];\n\n    if (i < pieces.length) {\n      const piece = pieces[i];\n      yield* processTemplatePiece(piece);\n    }\n  }\n}\n\n/**\n * Resolves a template piece into yielded string chunks.\n *\n * Skips output when `value === null || value === undefined || value === false`.\n * Otherwise awaits promises, flattens arrays, streams async iterables, invokes **functions** with no arguments and\n * recurses on the return value, and uses `String(value)` for primitives.\n */\nasync function* processTemplatePiece(\n  piece: MaybePromise<AsyncTemplatePiece>,\n): AsyncGenerator<string, void, unknown> {\n  if (piece === null || piece === undefined || piece === false) {\n    return;\n  }\n\n  if (piece instanceof Promise) {\n    const resolved = await piece;\n    yield* processTemplatePiece(resolved);\n    return;\n  }\n\n  if (Array.isArray(piece)) {\n    for (const item of piece) {\n      yield* processTemplatePiece(item);\n    }\n    return;\n  }\n\n  if (\n    typeof piece === 'object' &&\n    piece !== null &&\n    typeof (piece as AsyncIterable<unknown>)[Symbol.asyncIterator] ===\n      'function'\n  ) {\n    for await (const item of piece as AsyncIterable<AsyncTemplatePiece>) {\n      yield* processTemplatePiece(item);\n    }\n    return;\n  }\n\n  if (typeof piece === 'function') {\n    yield* processTemplatePiece(piece());\n    return;\n  }\n\n  yield String(piece);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,IAAa,SAAS,OAAe,GAAG,WACtC,IAAI,SAAe,SAAS,WAAW;AACrC,KAAI,QAAQ;EACV,MAAM,sBAAsB;AAC1B,gBAAa,QAAQ;AACrB,UAAO,QAAQ,OAAO;;EAExB,MAAM,UAAU,iBAAiB;AAC/B,UAAO,oBAAoB,SAAS,cAAc;AAClD,YAAS;KACR,KAAK;AACR,SAAO,iBAAiB,SAAS,eAAe,EAAE,MAAM,MAAM,CAAC;OAE/D,YAAW,SAAS,KAAK;EAE3B;;;;;;;;AASJ,IAAa,YAAY,OAAO,KAAK,QACnC,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnD,IAAa,cACX,cACA,gBACG;AACH,KAAI,cAAc,CAAE;CAEpB,MAAM,YACJ,4BAA4B,WAAW,cAAc,YAAY,CAAC;AAEpE,KAAI,YACF,gBAAe,IAAI;KAEnB,MAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,oBACd,UACA,WACA,QACA;CACA,IAAI,gBAA+B;CAEnC,MAAM,oBAAoB;AACxB,MAAI,iBAAiB,KACnB;AAEF,eAAa,cAAc;AAC3B,kBAAgB;;AAGlB,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,iBAAgB,iBAAiB;AAC/B,UAAQ,oBAAoB,SAAS,YAAY;AACjD,YAAU;IACT,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,SAAgB,qBACd,UACA,WACA,QACA;CACA,IAAI,QAAuB;CAE3B,MAAM,oBAAoB;AACxB,MAAI,SAAS,KACX;AAEF,gBAAc,MAAM;AACpB,UAAQ;;AAGV,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,SAAQ,YAAY,UAAU,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4E1C,gBAAuB,cACrB,SACA,GAAG,QACH;AACA,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,QAAM,QAAQ;AAEd,MAAI,IAAI,OAAO,QAAQ;GACrB,MAAM,QAAQ,OAAO;AACrB,UAAO,qBAAqB,MAAM;;;;;;;;;;;AAYxC,gBAAgB,qBACd,OACuC;AACvC,KAAI,UAAU,QAAQ,UAAU,KAAA,KAAa,UAAU,MACrD;AAGF,KAAI,iBAAiB,SAAS;AAE5B,SAAO,qBADU,MAAM,MACc;AACrC;;AAGF,KAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,OAAK,MAAM,QAAQ,MACjB,QAAO,qBAAqB,KAAK;AAEnC;;AAGF,KACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAiC,OAAO,mBAC9C,YACF;AACA,aAAW,MAAM,QAAQ,MACvB,QAAO,qBAAqB,KAAK;AAEnC;;AAGF,KAAI,OAAO,UAAU,YAAY;AAC/B,SAAO,qBAAqB,OAAO,CAAC;AACpC;;AAGF,OAAM,OAAO,MAAM"}
+{"version":3,"file":"async.cjs","names":[],"sources":["../src/async/async-template.ts","../src/async/endless-raf.ts","../src/async/set-abortable-interval.ts","../src/async/set-abortable-timeout.ts","../src/async/sleep.ts","../src/async/wait-async.ts"],"sourcesContent":["import type { MaybePromise } from 'yummies/types';\n\nimport type { AsyncTemplatePiece } from './async-template-piece.js';\n\n/**\n * Tagged template that builds an async iterable of string chunks (like a streaming template engine).\n *\n * Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,\n * a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a\n * **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).\n *\n * Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value\n * becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks\n * with `for await...of` or utilities like `Array.fromAsync` where available.\n *\n * @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).\n * @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).\n * @returns An async generator yielding string fragments in document order.\n *\n * @example\n * Plain values and promises:\n * ```ts\n * const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;\n * let out = '';\n * for await (const chunk of gen) out += chunk;\n * // out === 'Hello, world! Status: 200'\n * ```\n *\n * @example\n * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:\n * ```ts\n * const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;\n * const out = await Array.fromAsync(gen).then((parts) => parts.join(''));\n * // out === 'ABC'\n * ```\n *\n * @example\n * Stream from an async iterable (e.g. chunked upstream text):\n * ```ts\n * async function* lines() {\n *   yield 'line1\\n';\n *   yield 'line2\\n';\n * }\n * const gen = asyncTemplate`Header\\n${lines()}Footer`;\n * ```\n *\n * @example\n * Lazy piece via a thunk (invoked as `piece()`):\n * ```ts\n * let n = 0;\n * const gen = asyncTemplate`count=${() => ++n}`;\n * // first consumption yields \"count=1\", etc.\n * ```\n */\nexport async function* asyncTemplate(\n  strings: TemplateStringsArray,\n  ...pieces: MaybePromise<AsyncTemplatePiece>[]\n) {\n  for (let i = 0; i < strings.length; i++) {\n    yield strings[i];\n\n    if (i < pieces.length) {\n      const piece = pieces[i];\n      yield* processTemplatePiece(piece);\n    }\n  }\n}\n\n/**\n * Resolves a template piece into yielded string chunks.\n *\n * Skips output when `value === null || value === undefined || value === false`.\n * Otherwise awaits promises, flattens arrays, streams async iterables, invokes **functions** with no arguments and\n * recurses on the return value, and uses `String(value)` for primitives.\n */\nasync function* processTemplatePiece(\n  piece: MaybePromise<AsyncTemplatePiece>,\n): AsyncGenerator<string, void, unknown> {\n  if (piece === null || piece === undefined || piece === false) {\n    return;\n  }\n\n  if (piece instanceof Promise) {\n    const resolved = await piece;\n    yield* processTemplatePiece(resolved);\n    return;\n  }\n\n  if (Array.isArray(piece)) {\n    for (const item of piece) {\n      yield* processTemplatePiece(item);\n    }\n    return;\n  }\n\n  if (\n    typeof piece === 'object' &&\n    piece !== null &&\n    typeof (piece as AsyncIterable<unknown>)[Symbol.asyncIterator] ===\n      'function'\n  ) {\n    for await (const item of piece as AsyncIterable<AsyncTemplatePiece>) {\n      yield* processTemplatePiece(item);\n    }\n    return;\n  }\n\n  if (typeof piece === 'function') {\n    yield* processTemplatePiece(piece());\n    return;\n  }\n\n  yield String(piece);\n}\n","/**\n * Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.\n * If it returns a truthy value, the loop stops and no further frames are scheduled.\n * If it returns falsy or nothing, the next frame is scheduled recursively.\n *\n * Use this for per-frame work (animations, layout reads after paint) without managing\n * `cancelAnimationFrame` manually — returning `true` from `quitFunction` is the exit condition.\n *\n * When `asMicrotask` is `true`, scheduling the next RAF is deferred with `queueMicrotask`\n * so other microtasks can run before the frame is requested (useful when you need to\n * batch DOM updates or let reactive frameworks flush first).\n *\n * @param quitFunction - Invoked each animation frame. Return `true` to stop the loop.\n * @param asMicrotask - If `true`, wrap the `requestAnimationFrame` call in `queueMicrotask`.\n *\n * @example\n * Stop after 60 frames (~1s at 60Hz):\n * ```ts\n * let frames = 0;\n * endlessRAF(() => {\n *   frames++;\n *   updateSomething(frames);\n *   return frames >= 60;\n * });\n * ```\n *\n * @example\n * Run until an element is removed or a flag is set:\n * ```ts\n * let running = true;\n * endlessRAF(() => {\n *   if (!running || !document.body.contains(el)) return true;\n *   draw(el);\n * }, true);\n * ```\n */\nexport const endlessRAF = (\n  quitFunction: () => boolean | void,\n  asMicrotask?: boolean,\n) => {\n  if (quitFunction()) return;\n\n  const raf = () =>\n    requestAnimationFrame(() => endlessRAF(quitFunction, asMicrotask));\n\n  if (asMicrotask) {\n    queueMicrotask(raf);\n  } else {\n    raf();\n  }\n};\n","/**\n * Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`\n * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval\n * (you must clear it yourself).\n *\n * @param callback - Invoked every `delayInMs` milliseconds until aborted or cleared.\n * @param delayInMs - Interval period in milliseconds (same as `setInterval`).\n * @param signal - Aborting stops the interval and removes the abort listener path from keeping work alive.\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableInterval(() => console.log('tick'), 1000, controller.signal);\n * // stop: controller.abort();\n * ```\n *\n * @example\n * ```ts\n * const ac = new AbortController();\n * setAbortableInterval(syncStatus, 30_000, ac.signal);\n * window.addEventListener('beforeunload', () => ac.abort());\n * ```\n */\nexport function setAbortableInterval(\n  callback: VoidFunction,\n  delayInMs?: number,\n  signal?: AbortSignal,\n) {\n  let timer: number | null = null;\n\n  const handleAbort = () => {\n    if (timer == null) {\n      return;\n    }\n    clearInterval(timer);\n    timer = null;\n  };\n\n  signal?.addEventListener('abort', handleAbort, { once: true });\n\n  timer = setInterval(callback, delayInMs);\n}\n","/**\n * Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared\n * and `callback` is never run. If the callback runs normally, the abort listener is removed.\n *\n * Does nothing special if `signal` is omitted — behaves like a plain timeout.\n *\n * @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).\n * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).\n * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.\n *\n * @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableTimeout(() => console.log('done'), 500, controller.signal);\n * // later: controller.abort(); // timeout cancelled, log never runs\n * ```\n *\n * @example\n * Zero-delay scheduling that can still be cancelled before the macrotask runs:\n * ```ts\n * const ac = new AbortController();\n * setAbortableTimeout(() => startIntro(), 0, ac.signal);\n * // e.g. on teardown: ac.abort();\n * ```\n */\nexport function setAbortableTimeout(\n  callback: VoidFunction,\n  delayInMs?: number,\n  signal?: AbortSignal,\n) {\n  let internalTimer: number | null = null;\n\n  const handleAbort = () => {\n    if (internalTimer == null) {\n      return;\n    }\n    clearTimeout(internalTimer);\n    internalTimer = null;\n  };\n\n  signal?.addEventListener('abort', handleAbort, { once: true });\n\n  internalTimer = setTimeout(() => {\n    signal?.removeEventListener('abort', handleAbort);\n    callback();\n  }, delayInMs);\n}\n","/**\n * Returns a promise that resolves after `time` milliseconds.\n *\n * When `signal` is passed and becomes aborted before the delay elapses, the promise\n * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).\n * The timeout is cleared on abort so no resolve happens after cancellation.\n *\n * @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).\n * @param signal - Optional `AbortSignal` to cancel the wait early.\n * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.\n *\n * @example\n * Basic pause in an async function:\n * ```ts\n * await sleep(250);\n * console.log('after 250ms');\n * ```\n *\n * @example\n * Cancellable delay tied to component unmount or user action:\n * ```ts\n * const ac = new AbortController();\n * try {\n *   await sleep(5000, ac.signal);\n * } catch (e) {\n *   // aborted — e is signal.reason\n * }\n * ac.abort('user cancelled');\n * ```\n */\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n  new Promise<void>((resolve, reject) => {\n    if (signal) {\n      const abortListener = () => {\n        clearTimeout(timerId);\n        reject(signal?.reason);\n      };\n      const timerId = setTimeout(() => {\n        signal.removeEventListener('abort', abortListener);\n        resolve();\n      }, time);\n      signal.addEventListener('abort', abortListener, { once: true });\n    } else {\n      setTimeout(resolve, time);\n    }\n  });\n","import { sleep } from './sleep.js';\n\n/**\n * Creates a promise that resolves after the specified number of milliseconds.\n *\n * @deprecated Use `sleep` instead.\n * @param ms Delay in milliseconds.\n * @returns Promise\n */\nexport const waitAsync = (ms = 1000) => sleep(ms);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,gBAAuB,cACrB,SACA,GAAG,QACH;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,QAAQ;EAEd,IAAI,IAAI,OAAO,QAAQ;GACrB,MAAM,QAAQ,OAAO;GACrB,OAAO,qBAAqB,KAAK;EACnC;CACF;AACF;;;;;;;;AASA,gBAAgB,qBACd,OACuC;CACvC,IAAI,UAAU,QAAQ,UAAU,KAAA,KAAa,UAAU,OACrD;CAGF,IAAI,iBAAiB,SAAS;EAE5B,OAAO,qBAAqB,MADL,KACa;EACpC;CACF;CAEA,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,KAAK,MAAM,QAAQ,OACjB,OAAO,qBAAqB,IAAI;EAElC;CACF;CAEA,IACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAiC,OAAO,mBAC9C,YACF;EACA,WAAW,MAAM,QAAQ,OACvB,OAAO,qBAAqB,IAAI;EAElC;CACF;CAEA,IAAI,OAAO,UAAU,YAAY;EAC/B,OAAO,qBAAqB,MAAM,CAAC;EACnC;CACF;CAEA,MAAM,OAAO,KAAK;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC7EA,IAAa,cACX,cACA,gBACG;CACH,IAAI,aAAa,GAAG;CAEpB,MAAM,YACJ,4BAA4B,WAAW,cAAc,WAAW,CAAC;CAEnE,IAAI,aACF,eAAe,GAAG;MAElB,IAAI;AAER;;;;;;;;;;;;;;;;;;;;;;;;;;AC3BA,SAAgB,qBACd,UACA,WACA,QACA;CACA,IAAI,QAAuB;CAE3B,MAAM,oBAAoB;EACxB,IAAI,SAAS,MACX;EAEF,cAAc,KAAK;EACnB,QAAQ;CACV;CAEA,QAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,KAAK,CAAC;CAE7D,QAAQ,YAAY,UAAU,SAAS;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AChBA,SAAgB,oBACd,UACA,WACA,QACA;CACA,IAAI,gBAA+B;CAEnC,MAAM,oBAAoB;EACxB,IAAI,iBAAiB,MACnB;EAEF,aAAa,aAAa;EAC1B,gBAAgB;CAClB;CAEA,QAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,KAAK,CAAC;CAE7D,gBAAgB,iBAAiB;EAC/B,QAAQ,oBAAoB,SAAS,WAAW;EAChD,SAAS;CACX,GAAG,SAAS;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AChBA,IAAa,SAAS,OAAe,GAAG,WACtC,IAAI,SAAe,SAAS,WAAW;CACrC,IAAI,QAAQ;EACV,MAAM,sBAAsB;GAC1B,aAAa,OAAO;GACpB,OAAO,QAAQ,MAAM;EACvB;EACA,MAAM,UAAU,iBAAiB;GAC/B,OAAO,oBAAoB,SAAS,aAAa;GACjD,QAAQ;EACV,GAAG,IAAI;EACP,OAAO,iBAAiB,SAAS,eAAe,EAAE,MAAM,KAAK,CAAC;CAChE,OACE,WAAW,SAAS,IAAI;AAE5B,CAAC;;;;;;;;;;ACpCH,IAAa,aAAa,KAAK,QAAS,MAAM,EAAE"}