yummies 7.14.0 → 7.14.1

package/assert.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-CVq3Gv4J.cjs");
+let yummies_type_guard = require("yummies/type-guard");
 let yummies_common = require("yummies/common");
 //#region src/assert/_exports.ts
 /**
@@ -10,8 +11,8 @@ let yummies_common = require("yummies/common");
 *
 * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw
 * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays
-* explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and
-* the rest on the namespace export from the package entry.
+* explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,
+* `assert.fail`, and the rest on the namespace export from the package entry.
 *
 * ## Usage
 *
@@ -20,10 +21,12 @@ let yummies_common = require("yummies/common");
 *
 * assert.ok(user.id, "user id is required");
 * assert.defined(maybeName);
+* assert.string(raw);
 * ```
 */
 var _exports_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	AssertionError: () => AssertionError,
+	boolean: () => boolean,
 	defined: () => defined,
 	fail: () => fail,
 	instanceOf: () => instanceOf,
@@ -31,7 +34,10 @@ var _exports_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	never: () => unreachable,
 	notNull: () => notNull,
 	notUndefined: () => notUndefined,
+	number: () => number,
 	ok: () => ok,
+	string: () => string,
+	symbol: () => symbol,
 	unreachable: () => unreachable
 });
 /**
@@ -56,7 +62,7 @@ function resolveAssertMessage(message, fallback) {
 * ```
 */
 function ok(condition, message) {
-	if (!condition) throw new AssertionError(resolveAssertMessage(message, "Assertion failed"));
+	if (yummies_type_guard.typeGuard.isFalsy(condition)) throw new AssertionError(resolveAssertMessage(message, "Assertion failed"));
 }
 /**
 * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).
@@ -74,7 +80,7 @@ var invariant = ok;
 * ```
 */
 function defined(value, message) {
-	if (value == null) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+	if (!yummies_type_guard.typeGuard.isDefined(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
 }
 /**
 * Throws when the value is `null`; allows `undefined` unless combined with other checks.
@@ -83,7 +89,7 @@ function defined(value, message) {
 * @param message Optional message or lazy message factory.
 */
 function notNull(value, message) {
-	if (value === null) throw new AssertionError(resolveAssertMessage(message, "Expected a non-null value"));
+	if (yummies_type_guard.typeGuard.isNull(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a non-null value"));
 }
 /**
 * Throws when the value is `undefined`.
@@ -92,7 +98,43 @@ function notNull(value, message) {
 * @param message Optional message or lazy message factory.
 */
 function notUndefined(value, message) {
-	if (value === void 0) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+	if (yummies_type_guard.typeGuard.isUndefined(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+}
+/**
+* Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function string(value, message) {
+	if (!yummies_type_guard.typeGuard.isString(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a string"));
+}
+/**
+* Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function number(value, message) {
+	if (!yummies_type_guard.typeGuard.isNumber(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a finite number"));
+}
+/**
+* Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function boolean(value, message) {
+	if (!yummies_type_guard.typeGuard.isBoolean(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a boolean"));
+}
+/**
+* Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function symbol(value, message) {
+	if (!yummies_type_guard.typeGuard.isSymbol(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a symbol"));
 }
 /**
 * Always throws; use for branches that must be impossible or as a typed “abort”.

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.defined`, `assert.fail`, and\n * 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 * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport type { 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 (!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 (value == null) {\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 (value === null) {\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 (value === undefined) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,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,CAAC,UACH,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,SAAS,KACX,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,KACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,KAAA,EACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;;;;;;;;;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 { 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 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,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"}

package/assert.d.ts

@@ -1,4 +1,4 @@
-import { Maybe, MaybeFn } from 'yummies/types';
+import { MaybeFn, Maybe } from 'yummies/types';
 
 /**
  * ---header-docs-section---
@@ -8,8 +8,8 @@ import { Maybe, MaybeFn } from 'yummies/types';
  *
  * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw
  * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays
- * explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and
- * the rest on the namespace export from the package entry.
+ * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,
+ * `assert.fail`, and the rest on the namespace export from the package entry.
  *
  * ## Usage
  *
@@ -18,6 +18,7 @@ import { Maybe, MaybeFn } from 'yummies/types';
  *
  * assert.ok(user.id, "user id is required");
  * assert.defined(maybeName);
+ * assert.string(raw);
  * ```
  */
 
@@ -69,6 +70,34 @@ declare function notNull<T>(value: T | null, message?: MaybeFn<string>): asserts
  * @param message Optional message or lazy message factory.
  */
 declare function notUndefined<T>(value: T | undefined, message?: MaybeFn<string>): asserts value is T;
+/**
+ * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.
+ *
+ * @param value Value to narrow.
+ * @param message Optional message or lazy message factory.
+ */
+declare function string(value: unknown, message?: MaybeFn<string>): asserts value is string;
+/**
+ * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.
+ *
+ * @param value Value to narrow.
+ * @param message Optional message or lazy message factory.
+ */
+declare function number(value: unknown, message?: MaybeFn<string>): asserts value is number;
+/**
+ * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.
+ *
+ * @param value Value to narrow.
+ * @param message Optional message or lazy message factory.
+ */
+declare function boolean(value: unknown, message?: MaybeFn<string>): asserts value is boolean;
+/**
+ * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.
+ *
+ * @param value Value to narrow.
+ * @param message Optional message or lazy message factory.
+ */
+declare function symbol(value: unknown, message?: MaybeFn<string>): asserts value is symbol;
 /**
  * Always throws; use for branches that must be impossible or as a typed “abort”.
  *
@@ -108,17 +137,22 @@ declare function instanceOf<T>(value: unknown, ctor: abstract new (...args: neve
 
 type _exports_AssertionError = AssertionError;
 declare const _exports_AssertionError: typeof AssertionError;
+declare const _exports_boolean: typeof boolean;
 declare const _exports_defined: typeof defined;
 declare const _exports_fail: typeof fail;
 declare const _exports_instanceOf: typeof instanceOf;
 declare const _exports_invariant: typeof invariant;
 declare const _exports_notNull: typeof notNull;
 declare const _exports_notUndefined: typeof notUndefined;
+declare const _exports_number: typeof number;
 declare const _exports_ok: typeof ok;
+declare const _exports_string: typeof string;
+declare const _exports_symbol: typeof symbol;
 declare const _exports_unreachable: typeof unreachable;
 declare namespace _exports {
   export {
     _exports_AssertionError as AssertionError,
+    _exports_boolean as boolean,
     _exports_defined as defined,
     _exports_fail as fail,
     _exports_instanceOf as instanceOf,
@@ -126,7 +160,10 @@ declare namespace _exports {
     unreachable as never,
     _exports_notNull as notNull,
     _exports_notUndefined as notUndefined,
+    _exports_number as number,
     _exports_ok as ok,
+    _exports_string as string,
+    _exports_symbol as symbol,
     _exports_unreachable as unreachable,
   };
 }

package/assert.js

@@ -1,4 +1,5 @@
 import { n as __exportAll } from "./chunk-YKewjYmz.js";
+import { typeGuard } from "yummies/type-guard";
 import { callFunction } from "yummies/common";
 //#region src/assert/_exports.ts
 /**
@@ -9,8 +10,8 @@ import { callFunction } from "yummies/common";
 *
 * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw
 * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays
-* explicit without a heavy assertion library. Use `assert.ok`, `assert.defined`, `assert.fail`, and
-* the rest on the namespace export from the package entry.
+* explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,
+* `assert.fail`, and the rest on the namespace export from the package entry.
 *
 * ## Usage
 *
@@ -19,10 +20,12 @@ import { callFunction } from "yummies/common";
 *
 * assert.ok(user.id, "user id is required");
 * assert.defined(maybeName);
+* assert.string(raw);
 * ```
 */
 var _exports_exports = /* @__PURE__ */ __exportAll({
 	AssertionError: () => AssertionError,
+	boolean: () => boolean,
 	defined: () => defined,
 	fail: () => fail,
 	instanceOf: () => instanceOf,
@@ -30,7 +33,10 @@ var _exports_exports = /* @__PURE__ */ __exportAll({
 	never: () => unreachable,
 	notNull: () => notNull,
 	notUndefined: () => notUndefined,
+	number: () => number,
 	ok: () => ok,
+	string: () => string,
+	symbol: () => symbol,
 	unreachable: () => unreachable
 });
 /**
@@ -55,7 +61,7 @@ function resolveAssertMessage(message, fallback) {
 * ```
 */
 function ok(condition, message) {
-	if (!condition) throw new AssertionError(resolveAssertMessage(message, "Assertion failed"));
+	if (typeGuard.isFalsy(condition)) throw new AssertionError(resolveAssertMessage(message, "Assertion failed"));
 }
 /**
 * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).
@@ -73,7 +79,7 @@ var invariant = ok;
 * ```
 */
 function defined(value, message) {
-	if (value == null) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+	if (!typeGuard.isDefined(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
 }
 /**
 * Throws when the value is `null`; allows `undefined` unless combined with other checks.
@@ -82,7 +88,7 @@ function defined(value, message) {
 * @param message Optional message or lazy message factory.
 */
 function notNull(value, message) {
-	if (value === null) throw new AssertionError(resolveAssertMessage(message, "Expected a non-null value"));
+	if (typeGuard.isNull(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a non-null value"));
 }
 /**
 * Throws when the value is `undefined`.
@@ -91,7 +97,43 @@ function notNull(value, message) {
 * @param message Optional message or lazy message factory.
 */
 function notUndefined(value, message) {
-	if (value === void 0) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+	if (typeGuard.isUndefined(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a defined value"));
+}
+/**
+* Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function string(value, message) {
+	if (!typeGuard.isString(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a string"));
+}
+/**
+* Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function number(value, message) {
+	if (!typeGuard.isNumber(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a finite number"));
+}
+/**
+* Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function boolean(value, message) {
+	if (!typeGuard.isBoolean(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a boolean"));
+}
+/**
+* Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function symbol(value, message) {
+	if (!typeGuard.isSymbol(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a symbol"));
 }
 /**
 * Always throws; use for branches that must be impossible or as a typed “abort”.

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.defined`, `assert.fail`, and\n * 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 * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport type { 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 (!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 (value == null) {\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 (value === null) {\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 (value === undefined) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,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,CAAC,UACH,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,SAAS,KACX,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,KACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,KAAA,EACZ,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;;;;;;;;;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 { 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 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,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yummies",
-  "version": "7.14.0",
+  "version": "7.14.1",
   "keywords": [
     "javascript",
     "typescript",

package/type-guard.cjs

@@ -5,6 +5,7 @@ var _exports_exports = /* @__PURE__ */ require("./chunk-CVq3Gv4J.cjs").__exportA
 	isBoolean: () => isBoolean,
 	isDefined: () => isDefined,
 	isElement: () => isElement,
+	isFalsy: () => isFalsy,
 	isFunction: () => isFunction,
 	isInfinite: () => isInfinite,
 	isNaN: () => isNaN,
@@ -14,6 +15,7 @@ var _exports_exports = /* @__PURE__ */ require("./chunk-CVq3Gv4J.cjs").__exportA
 	isRegExp: () => isRegExp,
 	isString: () => isString,
 	isSymbol: () => isSymbol,
+	isTruthy: () => isTruthy,
 	isUndefined: () => isUndefined
 });
 var TYPE = {
@@ -63,6 +65,42 @@ var createTypeGuard = (...types) => (value) => types.includes(getType(value));
 */
 var isDefined = (value) => value != null;
 /**
+* Checks whether a value is truthy (same as `Boolean(value)` in `if (...)`).
+*
+* @param value Value to test.
+* @returns `true` when coercion to boolean is true.
+*
+* @example
+* ```ts
+* isTruthy(1); // true
+* ```
+*
+* @example
+* ```ts
+* isTruthy(0); // false
+* ```
+*/
+var isTruthy = (value) => Boolean(value);
+/**
+* Checks whether a value is falsy (same as `!value` / the `else` branch of `if (value)`).
+*
+* Includes `false`, `0`, `-0`, `NaN`, `""`, `null`, `undefined`, and `0n`.
+*
+* @param value Value to test.
+* @returns `true` when coercion to boolean is false.
+*
+* @example
+* ```ts
+* isFalsy(null); // true
+* ```
+*
+* @example
+* ```ts
+* isFalsy("x"); // false
+* ```
+*/
+var isFalsy = (value) => !value;
+/**
 * Checks whether a value is exactly `null`.
 *
 * @param value Value to test.

package/type-guard.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"type-guard.cjs","names":[],"sources":["../src/type-guard/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/type-guard\n *\n * ## Description\n *\n * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.\n * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so\n * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc\n * checks scattered through the codebase.\n *\n * ## Usage\n *\n * ```ts\n * import { typeGuard } from \"yummies/type-guard\";\n * ```\n */\n\nimport type { AnyFunction, AnyObject, ValueOf } from 'yummies/types';\n\nconst TYPE = {\n  Null: 'null',\n  Undefined: 'undefined',\n  NaN: 'nan',\n  Object: '[object Object]',\n  Array: '[object Array]',\n  String: '[object String]',\n  Number: '[object Number]',\n  Boolean: '[object Boolean]',\n  Function: '[object Function]',\n  AsyncFunction: '[object AsyncFunction]',\n  RegExp: '[object RegExp]',\n  Symbol: '[object Symbol]',\n  Infinite: 'infinite',\n  Element: 'element',\n};\n\ntype Type = ValueOf<typeof TYPE>;\n\nfunction getType(value: unknown): Type {\n  if (value === undefined) {\n    return TYPE.Undefined;\n  }\n  if (value === null) {\n    return TYPE.Null;\n  }\n\n  // handle DOM elements\n  // @ts-expect-error\n  if (value && (value.nodeType === 1 || value.nodeType === 9)) {\n    return TYPE.Element;\n  }\n\n  const stringifiedValue = Object.prototype.toString.call(value);\n\n  // handle NaN and Infinity\n  if (stringifiedValue === TYPE.Number) {\n    if (Number.isNaN(value as number)) {\n      return TYPE.NaN;\n    }\n    if (!Number.isFinite(value as number)) {\n      return TYPE.Infinite;\n    }\n  }\n\n  return stringifiedValue as Type;\n}\n\nconst createTypeGuard =\n  <T>(...types: Type[]) =>\n  (value: unknown): value is T =>\n    types.includes(getType(value));\n\n/**\n * Checks that a value is neither `null` nor `undefined`.\n *\n * @template T Value type without nullish branches.\n * @param value Value to test.\n * @returns `true` when the value is defined.\n *\n * @example\n * ```ts\n * isDefined(0); // true\n * ```\n *\n * @example\n * ```ts\n * isDefined(null); // false\n * ```\n */\nexport const isDefined = <T>(value: T | undefined | null): value is T =>\n  value != null;\n\n/**\n * Checks whether a value is exactly `null`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * ```\n *\n * @example\n * ```ts\n * isNull(undefined); // false\n * ```\n */\nexport const isNull = createTypeGuard<null>(TYPE.Null);\n\n/**\n * Checks whether a value is exactly `undefined`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * ```\n *\n * @example\n * ```ts\n * isUndefined('value'); // false\n * ```\n */\nexport const isUndefined = createTypeGuard<undefined>(TYPE.Undefined);\n\n/**\n * Checks whether a value is a plain object.\n *\n * @param value Value to test.\n * @returns `true` when the value matches `[object Object]`.\n *\n * @example\n * ```ts\n * isObject({ id: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObject([]); // false\n * ```\n */\nexport const isObject = createTypeGuard<AnyObject>(TYPE.Object);\n\n/**\n * Checks whether a value is an array.\n *\n * @param value Value to test.\n * @returns `true` when the value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]); // true\n * ```\n *\n * @example\n * ```ts\n * isArray({ length: 1 }); // false\n * ```\n */\nexport const isArray = createTypeGuard<unknown[]>(TYPE.Array);\n\n/**\n * Checks whether a value is a string object or primitive string.\n *\n * @param value Value to test.\n * @returns `true` when the value is a string.\n *\n * @example\n * ```ts\n * isString('hello'); // true\n * ```\n *\n * @example\n * ```ts\n * isString(123); // false\n * ```\n */\nexport const isString = createTypeGuard<string>(TYPE.String);\n\n/**\n * Checks whether a value is a finite number.\n *\n * Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.\n *\n * @param value Value to test.\n * @returns `true` when the value is a non-NaN finite number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * ```\n *\n * @example\n * ```ts\n * isNumber(Number.NaN); // false\n * ```\n */\nexport const isNumber = createTypeGuard<number>(TYPE.Number);\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value Value to test.\n * @returns `true` when the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * ```\n *\n * @example\n * ```ts\n * isBoolean('true'); // false\n * ```\n */\nexport const isBoolean = createTypeGuard<boolean>(TYPE.Boolean);\n\n/**\n * Checks whether a value is a synchronous or asynchronous function.\n *\n * @param value Value to test.\n * @returns `true` when the value is a function.\n *\n * @example\n * ```ts\n * isFunction(() => {}); // true\n * ```\n *\n * @example\n * ```ts\n * isFunction(async () => {}); // true\n * ```\n */\nexport const isFunction = createTypeGuard<AnyFunction>(\n  TYPE.Function,\n  TYPE.AsyncFunction,\n);\n\n/**\n * Checks whether a value is a regular expression.\n *\n * @param value Value to test.\n * @returns `true` when the value is a `RegExp`.\n *\n * @example\n * ```ts\n * isRegExp(/foo/); // true\n * ```\n *\n * @example\n * ```ts\n * isRegExp('foo'); // false\n * ```\n */\nexport const isRegExp = createTypeGuard<RegExp>(TYPE.RegExp);\n\n/**\n * Checks whether a value looks like a DOM element or document node.\n *\n * @param value Value to test.\n * @returns `true` when the value has an element-like node type.\n *\n * @example\n * ```ts\n * isElement(document.body); // true\n * ```\n *\n * @example\n * ```ts\n * isElement({ nodeType: 3 }); // false\n * ```\n */\nexport const isElement = createTypeGuard<HTMLElement>(TYPE.Element);\n\n/**\n * Checks whether a value is `NaN`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(Number.NaN); // true\n * ```\n *\n * @example\n * ```ts\n * isNaN(5); // false\n * ```\n */\nexport const isNaN = createTypeGuard<number>(TYPE.NaN) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is positive or negative infinity.\n *\n * @param value Value to test.\n * @returns `true` when the value is not finite.\n *\n * @example\n * ```ts\n * isInfinite(Infinity); // true\n * ```\n *\n * @example\n * ```ts\n * isInfinite(10); // false\n * ```\n */\nexport const isInfinite = createTypeGuard<number>(TYPE.Infinite) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is a symbol.\n *\n * @param value Value to test.\n * @returns `true` when the value is a symbol.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('id')); // true\n * ```\n *\n * @example\n * ```ts\n * isSymbol('id'); // false\n * ```\n */\nexport const isSymbol = createTypeGuard<symbol>(TYPE.Symbol);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAM,OAAO;CACX,MAAM;CACN,WAAW;CACX,KAAK;CACL,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,eAAe;CACf,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACV;AAID,SAAS,QAAQ,OAAsB;AACrC,KAAI,UAAU,KAAA,EACZ,QAAO,KAAK;AAEd,KAAI,UAAU,KACZ,QAAO,KAAK;AAKd,KAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,GACvD,QAAO,KAAK;CAGd,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,MAAM;AAG9D,KAAI,qBAAqB,KAAK,QAAQ;AACpC,MAAI,OAAO,MAAM,MAAgB,CAC/B,QAAO,KAAK;AAEd,MAAI,CAAC,OAAO,SAAS,MAAgB,CACnC,QAAO,KAAK;;AAIhB,QAAO;;AAGT,IAAM,mBACA,GAAG,WACN,UACC,MAAM,SAAS,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBlC,IAAa,aAAgB,UAC3B,SAAS;;;;;;;;;;;;;;;;;AAkBX,IAAa,SAAS,gBAAsB,KAAK,KAAK;;;;;;;;;;;;;;;;;AAkBtD,IAAa,cAAc,gBAA2B,KAAK,UAAU;;;;;;;;;;;;;;;;;AAkBrE,IAAa,WAAW,gBAA2B,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB/D,IAAa,UAAU,gBAA2B,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB7D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;;;AAoB5D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAAyB,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkB/D,IAAa,aAAa,gBACxB,KAAK,UACL,KAAK,cACN;;;;;;;;;;;;;;;;;AAkBD,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAA6B,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkBnE,IAAa,QAAQ,gBAAwB,KAAK,IAAI;;;;;;;;;;;;;;;;;AAoBtD,IAAa,aAAa,gBAAwB,KAAK,SAAS;;;;;;;;;;;;;;;;;AAoBhE,IAAa,WAAW,gBAAwB,KAAK,OAAO"}
+{"version":3,"file":"type-guard.cjs","names":[],"sources":["../src/type-guard/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/type-guard\n *\n * ## Description\n *\n * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.\n * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so\n * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc\n * checks scattered through the codebase.\n *\n * ## Usage\n *\n * ```ts\n * import { typeGuard } from \"yummies/type-guard\";\n * ```\n */\n\nimport type { AnyFunction, AnyObject, ValueOf } from 'yummies/types';\n\nconst TYPE = {\n  Null: 'null',\n  Undefined: 'undefined',\n  NaN: 'nan',\n  Object: '[object Object]',\n  Array: '[object Array]',\n  String: '[object String]',\n  Number: '[object Number]',\n  Boolean: '[object Boolean]',\n  Function: '[object Function]',\n  AsyncFunction: '[object AsyncFunction]',\n  RegExp: '[object RegExp]',\n  Symbol: '[object Symbol]',\n  Infinite: 'infinite',\n  Element: 'element',\n};\n\ntype Type = ValueOf<typeof TYPE>;\n\nfunction getType(value: unknown): Type {\n  if (value === undefined) {\n    return TYPE.Undefined;\n  }\n  if (value === null) {\n    return TYPE.Null;\n  }\n\n  // handle DOM elements\n  // @ts-expect-error\n  if (value && (value.nodeType === 1 || value.nodeType === 9)) {\n    return TYPE.Element;\n  }\n\n  const stringifiedValue = Object.prototype.toString.call(value);\n\n  // handle NaN and Infinity\n  if (stringifiedValue === TYPE.Number) {\n    if (Number.isNaN(value as number)) {\n      return TYPE.NaN;\n    }\n    if (!Number.isFinite(value as number)) {\n      return TYPE.Infinite;\n    }\n  }\n\n  return stringifiedValue as Type;\n}\n\nconst createTypeGuard =\n  <T>(...types: Type[]) =>\n  (value: unknown): value is T =>\n    types.includes(getType(value));\n\n/**\n * Checks that a value is neither `null` nor `undefined`.\n *\n * @template T Value type without nullish branches.\n * @param value Value to test.\n * @returns `true` when the value is defined.\n *\n * @example\n * ```ts\n * isDefined(0); // true\n * ```\n *\n * @example\n * ```ts\n * isDefined(null); // false\n * ```\n */\nexport const isDefined = <T>(value: T | undefined | null): value is T =>\n  value != null;\n\n/**\n * Checks whether a value is truthy (same as `Boolean(value)` in `if (...)`).\n *\n * @param value Value to test.\n * @returns `true` when coercion to boolean is true.\n *\n * @example\n * ```ts\n * isTruthy(1); // true\n * ```\n *\n * @example\n * ```ts\n * isTruthy(0); // false\n * ```\n */\nexport const isTruthy = (value: unknown): boolean => Boolean(value);\n\n/**\n * Checks whether a value is falsy (same as `!value` / the `else` branch of `if (value)`).\n *\n * Includes `false`, `0`, `-0`, `NaN`, `\"\"`, `null`, `undefined`, and `0n`.\n *\n * @param value Value to test.\n * @returns `true` when coercion to boolean is false.\n *\n * @example\n * ```ts\n * isFalsy(null); // true\n * ```\n *\n * @example\n * ```ts\n * isFalsy(\"x\"); // false\n * ```\n */\nexport const isFalsy = (value: unknown): boolean => !value;\n\n/**\n * Checks whether a value is exactly `null`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * ```\n *\n * @example\n * ```ts\n * isNull(undefined); // false\n * ```\n */\nexport const isNull = createTypeGuard<null>(TYPE.Null);\n\n/**\n * Checks whether a value is exactly `undefined`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * ```\n *\n * @example\n * ```ts\n * isUndefined('value'); // false\n * ```\n */\nexport const isUndefined = createTypeGuard<undefined>(TYPE.Undefined);\n\n/**\n * Checks whether a value is a plain object.\n *\n * @param value Value to test.\n * @returns `true` when the value matches `[object Object]`.\n *\n * @example\n * ```ts\n * isObject({ id: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObject([]); // false\n * ```\n */\nexport const isObject = createTypeGuard<AnyObject>(TYPE.Object);\n\n/**\n * Checks whether a value is an array.\n *\n * @param value Value to test.\n * @returns `true` when the value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]); // true\n * ```\n *\n * @example\n * ```ts\n * isArray({ length: 1 }); // false\n * ```\n */\nexport const isArray = createTypeGuard<unknown[]>(TYPE.Array);\n\n/**\n * Checks whether a value is a string object or primitive string.\n *\n * @param value Value to test.\n * @returns `true` when the value is a string.\n *\n * @example\n * ```ts\n * isString('hello'); // true\n * ```\n *\n * @example\n * ```ts\n * isString(123); // false\n * ```\n */\nexport const isString = createTypeGuard<string>(TYPE.String);\n\n/**\n * Checks whether a value is a finite number.\n *\n * Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.\n *\n * @param value Value to test.\n * @returns `true` when the value is a non-NaN finite number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * ```\n *\n * @example\n * ```ts\n * isNumber(Number.NaN); // false\n * ```\n */\nexport const isNumber = createTypeGuard<number>(TYPE.Number);\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value Value to test.\n * @returns `true` when the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * ```\n *\n * @example\n * ```ts\n * isBoolean('true'); // false\n * ```\n */\nexport const isBoolean = createTypeGuard<boolean>(TYPE.Boolean);\n\n/**\n * Checks whether a value is a synchronous or asynchronous function.\n *\n * @param value Value to test.\n * @returns `true` when the value is a function.\n *\n * @example\n * ```ts\n * isFunction(() => {}); // true\n * ```\n *\n * @example\n * ```ts\n * isFunction(async () => {}); // true\n * ```\n */\nexport const isFunction = createTypeGuard<AnyFunction>(\n  TYPE.Function,\n  TYPE.AsyncFunction,\n);\n\n/**\n * Checks whether a value is a regular expression.\n *\n * @param value Value to test.\n * @returns `true` when the value is a `RegExp`.\n *\n * @example\n * ```ts\n * isRegExp(/foo/); // true\n * ```\n *\n * @example\n * ```ts\n * isRegExp('foo'); // false\n * ```\n */\nexport const isRegExp = createTypeGuard<RegExp>(TYPE.RegExp);\n\n/**\n * Checks whether a value looks like a DOM element or document node.\n *\n * @param value Value to test.\n * @returns `true` when the value has an element-like node type.\n *\n * @example\n * ```ts\n * isElement(document.body); // true\n * ```\n *\n * @example\n * ```ts\n * isElement({ nodeType: 3 }); // false\n * ```\n */\nexport const isElement = createTypeGuard<HTMLElement>(TYPE.Element);\n\n/**\n * Checks whether a value is `NaN`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(Number.NaN); // true\n * ```\n *\n * @example\n * ```ts\n * isNaN(5); // false\n * ```\n */\nexport const isNaN = createTypeGuard<number>(TYPE.NaN) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is positive or negative infinity.\n *\n * @param value Value to test.\n * @returns `true` when the value is not finite.\n *\n * @example\n * ```ts\n * isInfinite(Infinity); // true\n * ```\n *\n * @example\n * ```ts\n * isInfinite(10); // false\n * ```\n */\nexport const isInfinite = createTypeGuard<number>(TYPE.Infinite) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is a symbol.\n *\n * @param value Value to test.\n * @returns `true` when the value is a symbol.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('id')); // true\n * ```\n *\n * @example\n * ```ts\n * isSymbol('id'); // false\n * ```\n */\nexport const isSymbol = createTypeGuard<symbol>(TYPE.Symbol);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,IAAM,OAAO;CACX,MAAM;CACN,WAAW;CACX,KAAK;CACL,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,eAAe;CACf,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACV;AAID,SAAS,QAAQ,OAAsB;AACrC,KAAI,UAAU,KAAA,EACZ,QAAO,KAAK;AAEd,KAAI,UAAU,KACZ,QAAO,KAAK;AAKd,KAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,GACvD,QAAO,KAAK;CAGd,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,MAAM;AAG9D,KAAI,qBAAqB,KAAK,QAAQ;AACpC,MAAI,OAAO,MAAM,MAAgB,CAC/B,QAAO,KAAK;AAEd,MAAI,CAAC,OAAO,SAAS,MAAgB,CACnC,QAAO,KAAK;;AAIhB,QAAO;;AAGT,IAAM,mBACA,GAAG,WACN,UACC,MAAM,SAAS,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBlC,IAAa,aAAgB,UAC3B,SAAS;;;;;;;;;;;;;;;;;AAkBX,IAAa,YAAY,UAA4B,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;AAoBnE,IAAa,WAAW,UAA4B,CAAC;;;;;;;;;;;;;;;;;AAkBrD,IAAa,SAAS,gBAAsB,KAAK,KAAK;;;;;;;;;;;;;;;;;AAkBtD,IAAa,cAAc,gBAA2B,KAAK,UAAU;;;;;;;;;;;;;;;;;AAkBrE,IAAa,WAAW,gBAA2B,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB/D,IAAa,UAAU,gBAA2B,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB7D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;;;AAoB5D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAAyB,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkB/D,IAAa,aAAa,gBACxB,KAAK,UACL,KAAK,cACN;;;;;;;;;;;;;;;;;AAkBD,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAA6B,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkBnE,IAAa,QAAQ,gBAAwB,KAAK,IAAI;;;;;;;;;;;;;;;;;AAoBtD,IAAa,aAAa,gBAAwB,KAAK,SAAS;;;;;;;;;;;;;;;;;AAoBhE,IAAa,WAAW,gBAAwB,KAAK,OAAO"}

package/type-guard.d.ts

@@ -36,6 +36,42 @@ import { AnyFunction, AnyObject } from 'yummies/types';
  * ```
  */
 declare const isDefined: <T>(value: T | undefined | null) => value is T;
+/**
+ * Checks whether a value is truthy (same as `Boolean(value)` in `if (...)`).
+ *
+ * @param value Value to test.
+ * @returns `true` when coercion to boolean is true.
+ *
+ * @example
+ * ```ts
+ * isTruthy(1); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * isTruthy(0); // false
+ * ```
+ */
+declare const isTruthy: (value: unknown) => boolean;
+/**
+ * Checks whether a value is falsy (same as `!value` / the `else` branch of `if (value)`).
+ *
+ * Includes `false`, `0`, `-0`, `NaN`, `""`, `null`, `undefined`, and `0n`.
+ *
+ * @param value Value to test.
+ * @returns `true` when coercion to boolean is false.
+ *
+ * @example
+ * ```ts
+ * isFalsy(null); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * isFalsy("x"); // false
+ * ```
+ */
+declare const isFalsy: (value: unknown) => boolean;
 /**
  * Checks whether a value is exactly `null`.
  *
@@ -264,6 +300,7 @@ declare const _exports_isArray: typeof isArray;
 declare const _exports_isBoolean: typeof isBoolean;
 declare const _exports_isDefined: typeof isDefined;
 declare const _exports_isElement: typeof isElement;
+declare const _exports_isFalsy: typeof isFalsy;
 declare const _exports_isFunction: typeof isFunction;
 declare const _exports_isInfinite: typeof isInfinite;
 declare const _exports_isNaN: typeof isNaN;
@@ -273,6 +310,7 @@ declare const _exports_isObject: typeof isObject;
 declare const _exports_isRegExp: typeof isRegExp;
 declare const _exports_isString: typeof isString;
 declare const _exports_isSymbol: typeof isSymbol;
+declare const _exports_isTruthy: typeof isTruthy;
 declare const _exports_isUndefined: typeof isUndefined;
 declare namespace _exports {
   export {
@@ -280,6 +318,7 @@ declare namespace _exports {
     _exports_isBoolean as isBoolean,
     _exports_isDefined as isDefined,
     _exports_isElement as isElement,
+    _exports_isFalsy as isFalsy,
     _exports_isFunction as isFunction,
     _exports_isInfinite as isInfinite,
     _exports_isNaN as isNaN,
@@ -289,6 +328,7 @@ declare namespace _exports {
     _exports_isRegExp as isRegExp,
     _exports_isString as isString,
     _exports_isSymbol as isSymbol,
+    _exports_isTruthy as isTruthy,
     _exports_isUndefined as isUndefined,
   };
 }

package/type-guard.js

@@ -5,6 +5,7 @@ var _exports_exports = /* @__PURE__ */ __exportAll({
 	isBoolean: () => isBoolean,
 	isDefined: () => isDefined,
 	isElement: () => isElement,
+	isFalsy: () => isFalsy,
 	isFunction: () => isFunction,
 	isInfinite: () => isInfinite,
 	isNaN: () => isNaN,
@@ -14,6 +15,7 @@ var _exports_exports = /* @__PURE__ */ __exportAll({
 	isRegExp: () => isRegExp,
 	isString: () => isString,
 	isSymbol: () => isSymbol,
+	isTruthy: () => isTruthy,
 	isUndefined: () => isUndefined
 });
 var TYPE = {
@@ -63,6 +65,42 @@ var createTypeGuard = (...types) => (value) => types.includes(getType(value));
 */
 var isDefined = (value) => value != null;
 /**
+* Checks whether a value is truthy (same as `Boolean(value)` in `if (...)`).
+*
+* @param value Value to test.
+* @returns `true` when coercion to boolean is true.
+*
+* @example
+* ```ts
+* isTruthy(1); // true
+* ```
+*
+* @example
+* ```ts
+* isTruthy(0); // false
+* ```
+*/
+var isTruthy = (value) => Boolean(value);
+/**
+* Checks whether a value is falsy (same as `!value` / the `else` branch of `if (value)`).
+*
+* Includes `false`, `0`, `-0`, `NaN`, `""`, `null`, `undefined`, and `0n`.
+*
+* @param value Value to test.
+* @returns `true` when coercion to boolean is false.
+*
+* @example
+* ```ts
+* isFalsy(null); // true
+* ```
+*
+* @example
+* ```ts
+* isFalsy("x"); // false
+* ```
+*/
+var isFalsy = (value) => !value;
+/**
 * Checks whether a value is exactly `null`.
 *
 * @param value Value to test.

package/type-guard.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-guard.js","names":[],"sources":["../src/type-guard/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/type-guard\n *\n * ## Description\n *\n * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.\n * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so\n * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc\n * checks scattered through the codebase.\n *\n * ## Usage\n *\n * ```ts\n * import { typeGuard } from \"yummies/type-guard\";\n * ```\n */\n\nimport type { AnyFunction, AnyObject, ValueOf } from 'yummies/types';\n\nconst TYPE = {\n  Null: 'null',\n  Undefined: 'undefined',\n  NaN: 'nan',\n  Object: '[object Object]',\n  Array: '[object Array]',\n  String: '[object String]',\n  Number: '[object Number]',\n  Boolean: '[object Boolean]',\n  Function: '[object Function]',\n  AsyncFunction: '[object AsyncFunction]',\n  RegExp: '[object RegExp]',\n  Symbol: '[object Symbol]',\n  Infinite: 'infinite',\n  Element: 'element',\n};\n\ntype Type = ValueOf<typeof TYPE>;\n\nfunction getType(value: unknown): Type {\n  if (value === undefined) {\n    return TYPE.Undefined;\n  }\n  if (value === null) {\n    return TYPE.Null;\n  }\n\n  // handle DOM elements\n  // @ts-expect-error\n  if (value && (value.nodeType === 1 || value.nodeType === 9)) {\n    return TYPE.Element;\n  }\n\n  const stringifiedValue = Object.prototype.toString.call(value);\n\n  // handle NaN and Infinity\n  if (stringifiedValue === TYPE.Number) {\n    if (Number.isNaN(value as number)) {\n      return TYPE.NaN;\n    }\n    if (!Number.isFinite(value as number)) {\n      return TYPE.Infinite;\n    }\n  }\n\n  return stringifiedValue as Type;\n}\n\nconst createTypeGuard =\n  <T>(...types: Type[]) =>\n  (value: unknown): value is T =>\n    types.includes(getType(value));\n\n/**\n * Checks that a value is neither `null` nor `undefined`.\n *\n * @template T Value type without nullish branches.\n * @param value Value to test.\n * @returns `true` when the value is defined.\n *\n * @example\n * ```ts\n * isDefined(0); // true\n * ```\n *\n * @example\n * ```ts\n * isDefined(null); // false\n * ```\n */\nexport const isDefined = <T>(value: T | undefined | null): value is T =>\n  value != null;\n\n/**\n * Checks whether a value is exactly `null`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * ```\n *\n * @example\n * ```ts\n * isNull(undefined); // false\n * ```\n */\nexport const isNull = createTypeGuard<null>(TYPE.Null);\n\n/**\n * Checks whether a value is exactly `undefined`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * ```\n *\n * @example\n * ```ts\n * isUndefined('value'); // false\n * ```\n */\nexport const isUndefined = createTypeGuard<undefined>(TYPE.Undefined);\n\n/**\n * Checks whether a value is a plain object.\n *\n * @param value Value to test.\n * @returns `true` when the value matches `[object Object]`.\n *\n * @example\n * ```ts\n * isObject({ id: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObject([]); // false\n * ```\n */\nexport const isObject = createTypeGuard<AnyObject>(TYPE.Object);\n\n/**\n * Checks whether a value is an array.\n *\n * @param value Value to test.\n * @returns `true` when the value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]); // true\n * ```\n *\n * @example\n * ```ts\n * isArray({ length: 1 }); // false\n * ```\n */\nexport const isArray = createTypeGuard<unknown[]>(TYPE.Array);\n\n/**\n * Checks whether a value is a string object or primitive string.\n *\n * @param value Value to test.\n * @returns `true` when the value is a string.\n *\n * @example\n * ```ts\n * isString('hello'); // true\n * ```\n *\n * @example\n * ```ts\n * isString(123); // false\n * ```\n */\nexport const isString = createTypeGuard<string>(TYPE.String);\n\n/**\n * Checks whether a value is a finite number.\n *\n * Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.\n *\n * @param value Value to test.\n * @returns `true` when the value is a non-NaN finite number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * ```\n *\n * @example\n * ```ts\n * isNumber(Number.NaN); // false\n * ```\n */\nexport const isNumber = createTypeGuard<number>(TYPE.Number);\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value Value to test.\n * @returns `true` when the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * ```\n *\n * @example\n * ```ts\n * isBoolean('true'); // false\n * ```\n */\nexport const isBoolean = createTypeGuard<boolean>(TYPE.Boolean);\n\n/**\n * Checks whether a value is a synchronous or asynchronous function.\n *\n * @param value Value to test.\n * @returns `true` when the value is a function.\n *\n * @example\n * ```ts\n * isFunction(() => {}); // true\n * ```\n *\n * @example\n * ```ts\n * isFunction(async () => {}); // true\n * ```\n */\nexport const isFunction = createTypeGuard<AnyFunction>(\n  TYPE.Function,\n  TYPE.AsyncFunction,\n);\n\n/**\n * Checks whether a value is a regular expression.\n *\n * @param value Value to test.\n * @returns `true` when the value is a `RegExp`.\n *\n * @example\n * ```ts\n * isRegExp(/foo/); // true\n * ```\n *\n * @example\n * ```ts\n * isRegExp('foo'); // false\n * ```\n */\nexport const isRegExp = createTypeGuard<RegExp>(TYPE.RegExp);\n\n/**\n * Checks whether a value looks like a DOM element or document node.\n *\n * @param value Value to test.\n * @returns `true` when the value has an element-like node type.\n *\n * @example\n * ```ts\n * isElement(document.body); // true\n * ```\n *\n * @example\n * ```ts\n * isElement({ nodeType: 3 }); // false\n * ```\n */\nexport const isElement = createTypeGuard<HTMLElement>(TYPE.Element);\n\n/**\n * Checks whether a value is `NaN`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(Number.NaN); // true\n * ```\n *\n * @example\n * ```ts\n * isNaN(5); // false\n * ```\n */\nexport const isNaN = createTypeGuard<number>(TYPE.NaN) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is positive or negative infinity.\n *\n * @param value Value to test.\n * @returns `true` when the value is not finite.\n *\n * @example\n * ```ts\n * isInfinite(Infinity); // true\n * ```\n *\n * @example\n * ```ts\n * isInfinite(10); // false\n * ```\n */\nexport const isInfinite = createTypeGuard<number>(TYPE.Infinite) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is a symbol.\n *\n * @param value Value to test.\n * @returns `true` when the value is a symbol.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('id')); // true\n * ```\n *\n * @example\n * ```ts\n * isSymbol('id'); // false\n * ```\n */\nexport const isSymbol = createTypeGuard<symbol>(TYPE.Symbol);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAM,OAAO;CACX,MAAM;CACN,WAAW;CACX,KAAK;CACL,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,eAAe;CACf,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACV;AAID,SAAS,QAAQ,OAAsB;AACrC,KAAI,UAAU,KAAA,EACZ,QAAO,KAAK;AAEd,KAAI,UAAU,KACZ,QAAO,KAAK;AAKd,KAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,GACvD,QAAO,KAAK;CAGd,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,MAAM;AAG9D,KAAI,qBAAqB,KAAK,QAAQ;AACpC,MAAI,OAAO,MAAM,MAAgB,CAC/B,QAAO,KAAK;AAEd,MAAI,CAAC,OAAO,SAAS,MAAgB,CACnC,QAAO,KAAK;;AAIhB,QAAO;;AAGT,IAAM,mBACA,GAAG,WACN,UACC,MAAM,SAAS,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBlC,IAAa,aAAgB,UAC3B,SAAS;;;;;;;;;;;;;;;;;AAkBX,IAAa,SAAS,gBAAsB,KAAK,KAAK;;;;;;;;;;;;;;;;;AAkBtD,IAAa,cAAc,gBAA2B,KAAK,UAAU;;;;;;;;;;;;;;;;;AAkBrE,IAAa,WAAW,gBAA2B,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB/D,IAAa,UAAU,gBAA2B,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB7D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;;;AAoB5D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAAyB,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkB/D,IAAa,aAAa,gBACxB,KAAK,UACL,KAAK,cACN;;;;;;;;;;;;;;;;;AAkBD,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAA6B,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkBnE,IAAa,QAAQ,gBAAwB,KAAK,IAAI;;;;;;;;;;;;;;;;;AAoBtD,IAAa,aAAa,gBAAwB,KAAK,SAAS;;;;;;;;;;;;;;;;;AAoBhE,IAAa,WAAW,gBAAwB,KAAK,OAAO"}
+{"version":3,"file":"type-guard.js","names":[],"sources":["../src/type-guard/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/type-guard\n *\n * ## Description\n *\n * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.\n * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so\n * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc\n * checks scattered through the codebase.\n *\n * ## Usage\n *\n * ```ts\n * import { typeGuard } from \"yummies/type-guard\";\n * ```\n */\n\nimport type { AnyFunction, AnyObject, ValueOf } from 'yummies/types';\n\nconst TYPE = {\n  Null: 'null',\n  Undefined: 'undefined',\n  NaN: 'nan',\n  Object: '[object Object]',\n  Array: '[object Array]',\n  String: '[object String]',\n  Number: '[object Number]',\n  Boolean: '[object Boolean]',\n  Function: '[object Function]',\n  AsyncFunction: '[object AsyncFunction]',\n  RegExp: '[object RegExp]',\n  Symbol: '[object Symbol]',\n  Infinite: 'infinite',\n  Element: 'element',\n};\n\ntype Type = ValueOf<typeof TYPE>;\n\nfunction getType(value: unknown): Type {\n  if (value === undefined) {\n    return TYPE.Undefined;\n  }\n  if (value === null) {\n    return TYPE.Null;\n  }\n\n  // handle DOM elements\n  // @ts-expect-error\n  if (value && (value.nodeType === 1 || value.nodeType === 9)) {\n    return TYPE.Element;\n  }\n\n  const stringifiedValue = Object.prototype.toString.call(value);\n\n  // handle NaN and Infinity\n  if (stringifiedValue === TYPE.Number) {\n    if (Number.isNaN(value as number)) {\n      return TYPE.NaN;\n    }\n    if (!Number.isFinite(value as number)) {\n      return TYPE.Infinite;\n    }\n  }\n\n  return stringifiedValue as Type;\n}\n\nconst createTypeGuard =\n  <T>(...types: Type[]) =>\n  (value: unknown): value is T =>\n    types.includes(getType(value));\n\n/**\n * Checks that a value is neither `null` nor `undefined`.\n *\n * @template T Value type without nullish branches.\n * @param value Value to test.\n * @returns `true` when the value is defined.\n *\n * @example\n * ```ts\n * isDefined(0); // true\n * ```\n *\n * @example\n * ```ts\n * isDefined(null); // false\n * ```\n */\nexport const isDefined = <T>(value: T | undefined | null): value is T =>\n  value != null;\n\n/**\n * Checks whether a value is truthy (same as `Boolean(value)` in `if (...)`).\n *\n * @param value Value to test.\n * @returns `true` when coercion to boolean is true.\n *\n * @example\n * ```ts\n * isTruthy(1); // true\n * ```\n *\n * @example\n * ```ts\n * isTruthy(0); // false\n * ```\n */\nexport const isTruthy = (value: unknown): boolean => Boolean(value);\n\n/**\n * Checks whether a value is falsy (same as `!value` / the `else` branch of `if (value)`).\n *\n * Includes `false`, `0`, `-0`, `NaN`, `\"\"`, `null`, `undefined`, and `0n`.\n *\n * @param value Value to test.\n * @returns `true` when coercion to boolean is false.\n *\n * @example\n * ```ts\n * isFalsy(null); // true\n * ```\n *\n * @example\n * ```ts\n * isFalsy(\"x\"); // false\n * ```\n */\nexport const isFalsy = (value: unknown): boolean => !value;\n\n/**\n * Checks whether a value is exactly `null`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * ```\n *\n * @example\n * ```ts\n * isNull(undefined); // false\n * ```\n */\nexport const isNull = createTypeGuard<null>(TYPE.Null);\n\n/**\n * Checks whether a value is exactly `undefined`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * ```\n *\n * @example\n * ```ts\n * isUndefined('value'); // false\n * ```\n */\nexport const isUndefined = createTypeGuard<undefined>(TYPE.Undefined);\n\n/**\n * Checks whether a value is a plain object.\n *\n * @param value Value to test.\n * @returns `true` when the value matches `[object Object]`.\n *\n * @example\n * ```ts\n * isObject({ id: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObject([]); // false\n * ```\n */\nexport const isObject = createTypeGuard<AnyObject>(TYPE.Object);\n\n/**\n * Checks whether a value is an array.\n *\n * @param value Value to test.\n * @returns `true` when the value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]); // true\n * ```\n *\n * @example\n * ```ts\n * isArray({ length: 1 }); // false\n * ```\n */\nexport const isArray = createTypeGuard<unknown[]>(TYPE.Array);\n\n/**\n * Checks whether a value is a string object or primitive string.\n *\n * @param value Value to test.\n * @returns `true` when the value is a string.\n *\n * @example\n * ```ts\n * isString('hello'); // true\n * ```\n *\n * @example\n * ```ts\n * isString(123); // false\n * ```\n */\nexport const isString = createTypeGuard<string>(TYPE.String);\n\n/**\n * Checks whether a value is a finite number.\n *\n * Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.\n *\n * @param value Value to test.\n * @returns `true` when the value is a non-NaN finite number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * ```\n *\n * @example\n * ```ts\n * isNumber(Number.NaN); // false\n * ```\n */\nexport const isNumber = createTypeGuard<number>(TYPE.Number);\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value Value to test.\n * @returns `true` when the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * ```\n *\n * @example\n * ```ts\n * isBoolean('true'); // false\n * ```\n */\nexport const isBoolean = createTypeGuard<boolean>(TYPE.Boolean);\n\n/**\n * Checks whether a value is a synchronous or asynchronous function.\n *\n * @param value Value to test.\n * @returns `true` when the value is a function.\n *\n * @example\n * ```ts\n * isFunction(() => {}); // true\n * ```\n *\n * @example\n * ```ts\n * isFunction(async () => {}); // true\n * ```\n */\nexport const isFunction = createTypeGuard<AnyFunction>(\n  TYPE.Function,\n  TYPE.AsyncFunction,\n);\n\n/**\n * Checks whether a value is a regular expression.\n *\n * @param value Value to test.\n * @returns `true` when the value is a `RegExp`.\n *\n * @example\n * ```ts\n * isRegExp(/foo/); // true\n * ```\n *\n * @example\n * ```ts\n * isRegExp('foo'); // false\n * ```\n */\nexport const isRegExp = createTypeGuard<RegExp>(TYPE.RegExp);\n\n/**\n * Checks whether a value looks like a DOM element or document node.\n *\n * @param value Value to test.\n * @returns `true` when the value has an element-like node type.\n *\n * @example\n * ```ts\n * isElement(document.body); // true\n * ```\n *\n * @example\n * ```ts\n * isElement({ nodeType: 3 }); // false\n * ```\n */\nexport const isElement = createTypeGuard<HTMLElement>(TYPE.Element);\n\n/**\n * Checks whether a value is `NaN`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(Number.NaN); // true\n * ```\n *\n * @example\n * ```ts\n * isNaN(5); // false\n * ```\n */\nexport const isNaN = createTypeGuard<number>(TYPE.NaN) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is positive or negative infinity.\n *\n * @param value Value to test.\n * @returns `true` when the value is not finite.\n *\n * @example\n * ```ts\n * isInfinite(Infinity); // true\n * ```\n *\n * @example\n * ```ts\n * isInfinite(10); // false\n * ```\n */\nexport const isInfinite = createTypeGuard<number>(TYPE.Infinite) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is a symbol.\n *\n * @param value Value to test.\n * @returns `true` when the value is a symbol.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('id')); // true\n * ```\n *\n * @example\n * ```ts\n * isSymbol('id'); // false\n * ```\n */\nexport const isSymbol = createTypeGuard<symbol>(TYPE.Symbol);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,IAAM,OAAO;CACX,MAAM;CACN,WAAW;CACX,KAAK;CACL,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,eAAe;CACf,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACV;AAID,SAAS,QAAQ,OAAsB;AACrC,KAAI,UAAU,KAAA,EACZ,QAAO,KAAK;AAEd,KAAI,UAAU,KACZ,QAAO,KAAK;AAKd,KAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,GACvD,QAAO,KAAK;CAGd,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,MAAM;AAG9D,KAAI,qBAAqB,KAAK,QAAQ;AACpC,MAAI,OAAO,MAAM,MAAgB,CAC/B,QAAO,KAAK;AAEd,MAAI,CAAC,OAAO,SAAS,MAAgB,CACnC,QAAO,KAAK;;AAIhB,QAAO;;AAGT,IAAM,mBACA,GAAG,WACN,UACC,MAAM,SAAS,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBlC,IAAa,aAAgB,UAC3B,SAAS;;;;;;;;;;;;;;;;;AAkBX,IAAa,YAAY,UAA4B,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;AAoBnE,IAAa,WAAW,UAA4B,CAAC;;;;;;;;;;;;;;;;;AAkBrD,IAAa,SAAS,gBAAsB,KAAK,KAAK;;;;;;;;;;;;;;;;;AAkBtD,IAAa,cAAc,gBAA2B,KAAK,UAAU;;;;;;;;;;;;;;;;;AAkBrE,IAAa,WAAW,gBAA2B,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB/D,IAAa,UAAU,gBAA2B,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB7D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;;;AAoB5D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAAyB,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkB/D,IAAa,aAAa,gBACxB,KAAK,UACL,KAAK,cACN;;;;;;;;;;;;;;;;;AAkBD,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAA6B,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkBnE,IAAa,QAAQ,gBAAwB,KAAK,IAAI;;;;;;;;;;;;;;;;;AAoBtD,IAAa,aAAa,gBAAwB,KAAK,SAAS;;;;;;;;;;;;;;;;;AAoBhE,IAAa,WAAW,gBAAwB,KAAK,OAAO"}