yummies 7.11.0 → 7.13.0

package/type-guard.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"type-guard.cjs","sources":["../src/type-guard/_exports.ts"],"sourcesContent":["import 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"],"names":[],"mappings":";;AAEA,MAAM,OAAO;AAAA,EACX,MAAM;AAAA,EACN,WAAW;AAAA,EACX,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,eAAe;AAAA,EACf,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,SAAS;AACX;AAIA,SAAS,QAAQ,OAAsB;AACrC,MAAI,UAAU,QAAW;AACvB,WAAO,KAAK;AAAA,EACd;AACA,MAAI,UAAU,MAAM;AAClB,WAAO,KAAK;AAAA,EACd;AAIA,MAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,IAAI;AAC3D,WAAO,KAAK;AAAA,EACd;AAEA,QAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,KAAK;AAG7D,MAAI,qBAAqB,KAAK,QAAQ;AACpC,QAAI,OAAO,MAAM,KAAe,GAAG;AACjC,aAAO,KAAK;AAAA,IACd;AACA,QAAI,CAAC,OAAO,SAAS,KAAe,GAAG;AACrC,aAAO,KAAK;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;AAEA,MAAM,kBACJ,IAAO,UACP,CAAC,UACC,MAAM,SAAS,QAAQ,KAAK,CAAC;AAmB1B,MAAM,YAAY,CAAI,UAC3B,SAAS;AAkBJ,MAAM,SAAS,gBAAsB,KAAK,IAAI;AAkB9C,MAAM,cAAc,gBAA2B,KAAK,SAAS;AAkB7D,MAAM,WAAW,gBAA2B,KAAK,MAAM;AAkBvD,MAAM,UAAU,gBAA2B,KAAK,KAAK;AAkBrD,MAAM,WAAW,gBAAwB,KAAK,MAAM;AAoBpD,MAAM,WAAW,gBAAwB,KAAK,MAAM;AAkBpD,MAAM,YAAY,gBAAyB,KAAK,OAAO;AAkBvD,MAAM,aAAa;AAAA,EACxB,KAAK;AAAA,EACL,KAAK;AACP;AAkBO,MAAM,WAAW,gBAAwB,KAAK,MAAM;AAkBpD,MAAM,YAAY,gBAA6B,KAAK,OAAO;AAkB3D,MAAM,QAAQ,gBAAwB,KAAK,GAAG;AAoB9C,MAAM,aAAa,gBAAwB,KAAK,QAAQ;AAoBxD,MAAM,WAAW,gBAAwB,KAAK,MAAM;;;;;;;;;;;;;;;;;;;"}
+{"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"}

package/type-guard.d.ts

@@ -1,5 +1,23 @@
 import { AnyFunction, AnyObject } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/type-guard
+ *
+ * ## Description
+ *
+ * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.
+ * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so
+ * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc
+ * checks scattered through the codebase.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { typeGuard } from "yummies/type-guard";
+ * ```
+ */
+
 /**
  * Checks that a value is neither `null` nor `undefined`.
  *

package/type-guard.js

@@ -1,76 +1,291 @@
-const TYPE = {
-  Null: "null",
-  Undefined: "undefined",
-  NaN: "nan",
-  Object: "[object Object]",
-  Array: "[object Array]",
-  String: "[object String]",
-  Number: "[object Number]",
-  Boolean: "[object Boolean]",
-  Function: "[object Function]",
-  AsyncFunction: "[object AsyncFunction]",
-  RegExp: "[object RegExp]",
-  Symbol: "[object Symbol]",
-  Infinite: "infinite",
-  Element: "element"
+import { n as __exportAll } from "./chunk-YKewjYmz.js";
+//#region src/type-guard/_exports.ts
+var _exports_exports = /* @__PURE__ */ __exportAll({
+	isArray: () => isArray,
+	isBoolean: () => isBoolean,
+	isDefined: () => isDefined,
+	isElement: () => isElement,
+	isFunction: () => isFunction,
+	isInfinite: () => isInfinite,
+	isNaN: () => isNaN,
+	isNull: () => isNull,
+	isNumber: () => isNumber,
+	isObject: () => isObject,
+	isRegExp: () => isRegExp,
+	isString: () => isString,
+	isSymbol: () => isSymbol,
+	isUndefined: () => isUndefined
+});
+var TYPE = {
+	Null: "null",
+	Undefined: "undefined",
+	NaN: "nan",
+	Object: "[object Object]",
+	Array: "[object Array]",
+	String: "[object String]",
+	Number: "[object Number]",
+	Boolean: "[object Boolean]",
+	Function: "[object Function]",
+	AsyncFunction: "[object AsyncFunction]",
+	RegExp: "[object RegExp]",
+	Symbol: "[object Symbol]",
+	Infinite: "infinite",
+	Element: "element"
 };
 function getType(value) {
-  if (value === void 0) {
-    return TYPE.Undefined;
-  }
-  if (value === null) {
-    return TYPE.Null;
-  }
-  if (value && (value.nodeType === 1 || value.nodeType === 9)) {
-    return TYPE.Element;
-  }
-  const stringifiedValue = Object.prototype.toString.call(value);
-  if (stringifiedValue === TYPE.Number) {
-    if (Number.isNaN(value)) {
-      return TYPE.NaN;
-    }
-    if (!Number.isFinite(value)) {
-      return TYPE.Infinite;
-    }
-  }
-  return stringifiedValue;
+	if (value === void 0) return TYPE.Undefined;
+	if (value === null) return TYPE.Null;
+	if (value && (value.nodeType === 1 || value.nodeType === 9)) return TYPE.Element;
+	const stringifiedValue = Object.prototype.toString.call(value);
+	if (stringifiedValue === TYPE.Number) {
+		if (Number.isNaN(value)) return TYPE.NaN;
+		if (!Number.isFinite(value)) return TYPE.Infinite;
+	}
+	return stringifiedValue;
 }
-const createTypeGuard = (...types) => (value) => types.includes(getType(value));
-const isDefined = (value) => value != null;
-const isNull = createTypeGuard(TYPE.Null);
-const isUndefined = createTypeGuard(TYPE.Undefined);
-const isObject = createTypeGuard(TYPE.Object);
-const isArray = createTypeGuard(TYPE.Array);
-const isString = createTypeGuard(TYPE.String);
-const isNumber = createTypeGuard(TYPE.Number);
-const isBoolean = createTypeGuard(TYPE.Boolean);
-const isFunction = createTypeGuard(
-  TYPE.Function,
-  TYPE.AsyncFunction
-);
-const isRegExp = createTypeGuard(TYPE.RegExp);
-const isElement = createTypeGuard(TYPE.Element);
-const isNaN = createTypeGuard(TYPE.NaN);
-const isInfinite = createTypeGuard(TYPE.Infinite);
-const isSymbol = createTypeGuard(TYPE.Symbol);
-const _exports = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  isArray,
-  isBoolean,
-  isDefined,
-  isElement,
-  isFunction,
-  isInfinite,
-  isNaN,
-  isNull,
-  isNumber,
-  isObject,
-  isRegExp,
-  isString,
-  isSymbol,
-  isUndefined
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  _exports as typeGuard
-};
-//# sourceMappingURL=type-guard.js.map
+var createTypeGuard = (...types) => (value) => types.includes(getType(value));
+/**
+* Checks that a value is neither `null` nor `undefined`.
+*
+* @template T Value type without nullish branches.
+* @param value Value to test.
+* @returns `true` when the value is defined.
+*
+* @example
+* ```ts
+* isDefined(0); // true
+* ```
+*
+* @example
+* ```ts
+* isDefined(null); // false
+* ```
+*/
+var isDefined = (value) => value != null;
+/**
+* Checks whether a value is exactly `null`.
+*
+* @param value Value to test.
+* @returns `true` when the value is `null`.
+*
+* @example
+* ```ts
+* isNull(null); // true
+* ```
+*
+* @example
+* ```ts
+* isNull(undefined); // false
+* ```
+*/
+var isNull = createTypeGuard(TYPE.Null);
+/**
+* Checks whether a value is exactly `undefined`.
+*
+* @param value Value to test.
+* @returns `true` when the value is `undefined`.
+*
+* @example
+* ```ts
+* isUndefined(undefined); // true
+* ```
+*
+* @example
+* ```ts
+* isUndefined('value'); // false
+* ```
+*/
+var isUndefined = createTypeGuard(TYPE.Undefined);
+/**
+* Checks whether a value is a plain object.
+*
+* @param value Value to test.
+* @returns `true` when the value matches `[object Object]`.
+*
+* @example
+* ```ts
+* isObject({ id: 1 }); // true
+* ```
+*
+* @example
+* ```ts
+* isObject([]); // false
+* ```
+*/
+var isObject = createTypeGuard(TYPE.Object);
+/**
+* Checks whether a value is an array.
+*
+* @param value Value to test.
+* @returns `true` when the value is an array.
+*
+* @example
+* ```ts
+* isArray([1, 2, 3]); // true
+* ```
+*
+* @example
+* ```ts
+* isArray({ length: 1 }); // false
+* ```
+*/
+var isArray = createTypeGuard(TYPE.Array);
+/**
+* Checks whether a value is a string object or primitive string.
+*
+* @param value Value to test.
+* @returns `true` when the value is a string.
+*
+* @example
+* ```ts
+* isString('hello'); // true
+* ```
+*
+* @example
+* ```ts
+* isString(123); // false
+* ```
+*/
+var isString = createTypeGuard(TYPE.String);
+/**
+* Checks whether a value is a finite number.
+*
+* Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.
+*
+* @param value Value to test.
+* @returns `true` when the value is a non-NaN finite number.
+*
+* @example
+* ```ts
+* isNumber(123); // true
+* ```
+*
+* @example
+* ```ts
+* isNumber(Number.NaN); // false
+* ```
+*/
+var isNumber = createTypeGuard(TYPE.Number);
+/**
+* Checks whether a value is a boolean.
+*
+* @param value Value to test.
+* @returns `true` when the value is a boolean.
+*
+* @example
+* ```ts
+* isBoolean(true); // true
+* ```
+*
+* @example
+* ```ts
+* isBoolean('true'); // false
+* ```
+*/
+var isBoolean = createTypeGuard(TYPE.Boolean);
+/**
+* Checks whether a value is a synchronous or asynchronous function.
+*
+* @param value Value to test.
+* @returns `true` when the value is a function.
+*
+* @example
+* ```ts
+* isFunction(() => {}); // true
+* ```
+*
+* @example
+* ```ts
+* isFunction(async () => {}); // true
+* ```
+*/
+var isFunction = createTypeGuard(TYPE.Function, TYPE.AsyncFunction);
+/**
+* Checks whether a value is a regular expression.
+*
+* @param value Value to test.
+* @returns `true` when the value is a `RegExp`.
+*
+* @example
+* ```ts
+* isRegExp(/foo/); // true
+* ```
+*
+* @example
+* ```ts
+* isRegExp('foo'); // false
+* ```
+*/
+var isRegExp = createTypeGuard(TYPE.RegExp);
+/**
+* Checks whether a value looks like a DOM element or document node.
+*
+* @param value Value to test.
+* @returns `true` when the value has an element-like node type.
+*
+* @example
+* ```ts
+* isElement(document.body); // true
+* ```
+*
+* @example
+* ```ts
+* isElement({ nodeType: 3 }); // false
+* ```
+*/
+var isElement = createTypeGuard(TYPE.Element);
+/**
+* Checks whether a value is `NaN`.
+*
+* @param value Value to test.
+* @returns `true` when the value is `NaN`.
+*
+* @example
+* ```ts
+* isNaN(Number.NaN); // true
+* ```
+*
+* @example
+* ```ts
+* isNaN(5); // false
+* ```
+*/
+var isNaN = createTypeGuard(TYPE.NaN);
+/**
+* Checks whether a value is positive or negative infinity.
+*
+* @param value Value to test.
+* @returns `true` when the value is not finite.
+*
+* @example
+* ```ts
+* isInfinite(Infinity); // true
+* ```
+*
+* @example
+* ```ts
+* isInfinite(10); // false
+* ```
+*/
+var isInfinite = createTypeGuard(TYPE.Infinite);
+/**
+* Checks whether a value is a symbol.
+*
+* @param value Value to test.
+* @returns `true` when the value is a symbol.
+*
+* @example
+* ```ts
+* isSymbol(Symbol('id')); // true
+* ```
+*
+* @example
+* ```ts
+* isSymbol('id'); // false
+* ```
+*/
+var isSymbol = createTypeGuard(TYPE.Symbol);
+//#endregion
+export { _exports_exports as typeGuard };
+
+//# sourceMappingURL=type-guard.js.map

package/type-guard.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-guard.js","sources":["../src/type-guard/_exports.ts"],"sourcesContent":["import 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"],"names":[],"mappings":"AAEA,MAAM,OAAO;AAAA,EACX,MAAM;AAAA,EACN,WAAW;AAAA,EACX,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,eAAe;AAAA,EACf,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,SAAS;AACX;AAIA,SAAS,QAAQ,OAAsB;AACrC,MAAI,UAAU,QAAW;AACvB,WAAO,KAAK;AAAA,EACd;AACA,MAAI,UAAU,MAAM;AAClB,WAAO,KAAK;AAAA,EACd;AAIA,MAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,IAAI;AAC3D,WAAO,KAAK;AAAA,EACd;AAEA,QAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,KAAK;AAG7D,MAAI,qBAAqB,KAAK,QAAQ;AACpC,QAAI,OAAO,MAAM,KAAe,GAAG;AACjC,aAAO,KAAK;AAAA,IACd;AACA,QAAI,CAAC,OAAO,SAAS,KAAe,GAAG;AACrC,aAAO,KAAK;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;AAEA,MAAM,kBACJ,IAAO,UACP,CAAC,UACC,MAAM,SAAS,QAAQ,KAAK,CAAC;AAmB1B,MAAM,YAAY,CAAI,UAC3B,SAAS;AAkBJ,MAAM,SAAS,gBAAsB,KAAK,IAAI;AAkB9C,MAAM,cAAc,gBAA2B,KAAK,SAAS;AAkB7D,MAAM,WAAW,gBAA2B,KAAK,MAAM;AAkBvD,MAAM,UAAU,gBAA2B,KAAK,KAAK;AAkBrD,MAAM,WAAW,gBAAwB,KAAK,MAAM;AAoBpD,MAAM,WAAW,gBAAwB,KAAK,MAAM;AAkBpD,MAAM,YAAY,gBAAyB,KAAK,OAAO;AAkBvD,MAAM,aAAa;AAAA,EACxB,KAAK;AAAA,EACL,KAAK;AACP;AAkBO,MAAM,WAAW,gBAAwB,KAAK,MAAM;AAkBpD,MAAM,YAAY,gBAA6B,KAAK,OAAO;AAkB3D,MAAM,QAAQ,gBAAwB,KAAK,GAAG;AAoB9C,MAAM,aAAa,gBAAwB,KAAK,QAAQ;AAoBxD,MAAM,WAAW,gBAAwB,KAAK,MAAM;;;;;;;;;;;;;;;;;;"}
+{"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"}

package/types.cjs

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=types.cjs.map

package/types.d.ts

@@ -1,3 +1,44 @@
+/**
+ * ---header-docs-section---
+ * # yummies/types
+ *
+ * ## Description
+ *
+ * This module collects **TypeScript-only** helpers: `ValueOf`, nullable aliases, branded types, and
+ * patterns for props and generics. Nothing here exists at runtime — use `import type` so bundlers
+ * drop the imports entirely. The same ideas are also published as **ambient** globals under a
+ * separate entry (see below) when you want types in scope without repeating imports in every file.
+ *
+ * ## `yummies/types.global`
+ *
+ * Use this subpath when you prefer **global** declarations (no per-file imports). After installing
+ * the package, reference the built `.d.ts` bundle — typically via a side-effect import that pulls
+ * ambient types into the compilation unit:
+ *
+ * ```ts
+ * import "yummies/types.global";
+ * ```
+ *
+ * Or list it under `compilerOptions.types` in **`tsconfig.json`** so `tsc` loads it for the project:
+ *
+ * ```json
+ * {
+ *   "compilerOptions": {
+ *     "types": ["yummies/types.global"]
+ *   }
+ * }
+ * ```
+ *
+ * ## `yummies/types` (library)
+ *
+ * Prefer this entry when you want **explicit**, traceable imports at each call site (tree-shaking
+ * friendly and clearer in reviews). The root package may re-export some symbols, but
+ * **`yummies/types`** is the dedicated surface for type-only utilities.
+ *
+ * ```ts
+ * import type { AnyObject, Maybe } from "yummies/types";
+ * ```
+ */
 /**
  * Extracts all values from an object or array type.
  *

package/types.global.cjs

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=types.global.cjs.map

package/types.global.d.ts

@@ -1,4 +1,45 @@
 /** THIS IS AUTOGENERATED FILE FROM "utils/types.ts" */
+/**
+ * ---header-docs-section---
+ * # yummies/types
+ *
+ * ## Description
+ *
+ * This module collects **TypeScript-only** helpers: `ValueOf`, nullable aliases, branded types, and
+ * patterns for props and generics. Nothing here exists at runtime — use `import type` so bundlers
+ * drop the imports entirely. The same ideas are also published as **ambient** globals under a
+ * separate entry (see below) when you want types in scope without repeating imports in every file.
+ *
+ * ## `yummies/types.global`
+ *
+ * Use this subpath when you prefer **global** declarations (no per-file imports). After installing
+ * the package, reference the built `.d.ts` bundle — typically via a side-effect import that pulls
+ * ambient types into the compilation unit:
+ *
+ * ```ts
+ * import "yummies/types.global";
+ * ```
+ *
+ * Or list it under `compilerOptions.types` in **`tsconfig.json`** so `tsc` loads it for the project:
+ *
+ * ```json
+ * {
+ *   "compilerOptions": {
+ *     "types": ["yummies/types.global"]
+ *   }
+ * }
+ * ```
+ *
+ * ## `yummies/types` (library)
+ *
+ * Prefer this entry when you want **explicit**, traceable imports at each call site (tree-shaking
+ * friendly and clearer in reviews). The root package may re-export some symbols, but
+ * **`yummies/types`** is the dedicated surface for type-only utilities.
+ *
+ * ```ts
+ * import type { AnyObject, Maybe } from "yummies/types";
+ * ```
+ */
 /**
  * Extracts all values from an object or array type.
  *

package/types.global.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.global.js.map

package/types.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.js.map

package/vibrate.cjs

@@ -1,9 +1,50 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const vibrate = (pattern) => {
-  if ("vibrate" in navigator) {
-    navigator.vibrate(pattern);
-  }
+//#region src/vibrate.ts
+/**
+* ---header-docs-section---
+* # yummies/vibrate
+*
+* ## Description
+*
+* Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned
+* on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not
+* rely on vibration for critical feedback because iOS and many desktops omit the API entirely.
+*
+* ## Usage
+*
+* ```ts
+* import { vibrate } from "yummies/vibrate";
+* ```
+*/
+/**
+* Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}
+* when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).
+*
+* - **Single number** — vibrate for that many milliseconds, then stop.
+* - **Array of numbers** — alternating vibration and pause lengths in ms: `[vibrate, pause, vibrate, ...]`.
+*   Per the spec, values are clamped; odd-length arrays imply a trailing vibrate segment.
+*
+* If the API is unavailable or the user has disabled vibration, this function **does nothing**
+* (no throw). Call sites should not rely on vibration for critical UX.
+*
+* @param pattern - Duration in ms, or a pattern array as described above.
+*
+* @example
+* Short confirmation buzz (200 ms):
+* ```ts
+* vibrate(200);
+* ```
+*
+* @example
+* Double-pulse pattern: 100 ms on, 50 ms off, 100 ms on:
+* ```ts
+* vibrate([100, 50, 100]);
+* ```
+*/
+var vibrate = (pattern) => {
+	if ("vibrate" in navigator) navigator.vibrate(pattern);
 };
+//#endregion
 exports.vibrate = vibrate;
-//# sourceMappingURL=vibrate.cjs.map
+
+//# sourceMappingURL=vibrate.cjs.map

package/vibrate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"vibrate.cjs","sources":["../src/vibrate.ts"],"sourcesContent":["/**\n * Triggers vibration using the provided pattern.\n */\nexport const vibrate = (pattern: number | number[]) => {\n  if ('vibrate' in navigator) {\n    navigator.vibrate(pattern);\n  }\n};\n"],"names":[],"mappings":";;AAGO,MAAM,UAAU,CAAC,YAA+B;AACrD,MAAI,aAAa,WAAW;AAC1B,cAAU,QAAQ,OAAO;AAAA,EAC3B;AACF;;"}
+{"version":3,"file":"vibrate.cjs","names":[],"sources":["../src/vibrate.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/vibrate\n *\n * ## Description\n *\n * Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned\n * on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not\n * rely on vibration for critical feedback because iOS and many desktops omit the API entirely.\n *\n * ## Usage\n *\n * ```ts\n * import { vibrate } from \"yummies/vibrate\";\n * ```\n */\n\n/**\n * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}\n * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).\n *\n * - **Single number** — vibrate for that many milliseconds, then stop.\n * - **Array of numbers** — alternating vibration and pause lengths in ms: `[vibrate, pause, vibrate, ...]`.\n *   Per the spec, values are clamped; odd-length arrays imply a trailing vibrate segment.\n *\n * If the API is unavailable or the user has disabled vibration, this function **does nothing**\n * (no throw). Call sites should not rely on vibration for critical UX.\n *\n * @param pattern - Duration in ms, or a pattern array as described above.\n *\n * @example\n * Short confirmation buzz (200 ms):\n * ```ts\n * vibrate(200);\n * ```\n *\n * @example\n * Double-pulse pattern: 100 ms on, 50 ms off, 100 ms on:\n * ```ts\n * vibrate([100, 50, 100]);\n * ```\n */\nexport const vibrate = (pattern: number | number[]) => {\n  if ('vibrate' in navigator) {\n    navigator.vibrate(pattern);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,WAAW,YAA+B;AACrD,KAAI,aAAa,UACf,WAAU,QAAQ,QAAQ"}