yummies 7.11.0 → 7.13.0

package/text.cjs

@@ -1,38 +1,71 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const declension = (count, txt, cases = [2, 0, 1, 1, 1, 2]) => txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];
-const splitTextByLines = (text, lineLingth = 60) => {
-  const words = text.split(/\s+/).filter((word) => word !== "");
-  const lines = [];
-  let currentLine = "";
-  for (const word of words) {
-    if (word.length > lineLingth) {
-      if (currentLine !== "") {
-        lines.push(currentLine);
-        currentLine = "";
-      }
-      let start = 0;
-      while (start < word.length) {
-        const chunk = word.slice(start, start + lineLingth);
-        lines.push(chunk);
-        start += lineLingth;
-      }
-      continue;
-    }
-    if (currentLine === "") {
-      currentLine = word;
-    } else if (currentLine.length + 1 + word.length <= lineLingth) {
-      currentLine += ` ${word}`;
-    } else {
-      lines.push(currentLine);
-      currentLine = word;
-    }
-  }
-  if (currentLine !== "" || lines.length === 0) {
-    lines.push(currentLine);
-  }
-  return lines;
+//#region src/text.ts
+/**
+* ---header-docs-section---
+* # yummies/text
+*
+* ## Description
+*
+* Russian-centric text helpers: **declension** by count (одно слово / два слова / пять слов) and
+* utilities for splitting long strings into wrapped lines. Pair with `yummies/date-time` for
+* natural language timestamps and labels in Slavic locales.
+*
+* ## Usage
+*
+* ```ts
+* import { declension } from "yummies/text";
+* ```
+*/
+/**
+* Returns the correct word form based on the provided count.
+* @example
+* declension(1, ['slovo', 'slova', 'slov']) // 'slovo'
+* @example
+* declension(2, ['slovo', 'slova', 'slov']) // 'slova'
+* @example
+* declension(5, ['slovo', 'slova', 'slov']) // 'slov'
+*/
+var declension = (count, txt, cases = [
+	2,
+	0,
+	1,
+	1,
+	1,
+	2
+]) => txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];
+/**
+* Splits text into lines with a maximum line length.
+*/
+var splitTextByLines = (text, lineLingth = 60) => {
+	const words = text.split(/\s+/).filter((word) => word !== "");
+	const lines = [];
+	let currentLine = "";
+	for (const word of words) {
+		if (word.length > lineLingth) {
+			if (currentLine !== "") {
+				lines.push(currentLine);
+				currentLine = "";
+			}
+			let start = 0;
+			while (start < word.length) {
+				const chunk = word.slice(start, start + lineLingth);
+				lines.push(chunk);
+				start += lineLingth;
+			}
+			continue;
+		}
+		if (currentLine === "") currentLine = word;
+		else if (currentLine.length + 1 + word.length <= lineLingth) currentLine += ` ${word}`;
+		else {
+			lines.push(currentLine);
+			currentLine = word;
+		}
+	}
+	if (currentLine !== "" || lines.length === 0) lines.push(currentLine);
+	return lines;
 };
+//#endregion
 exports.declension = declension;
 exports.splitTextByLines = splitTextByLines;
-//# sourceMappingURL=text.cjs.map
+
+//# sourceMappingURL=text.cjs.map

package/text.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"text.cjs","sources":["../src/text.ts"],"sourcesContent":["/**\n * Returns the correct word form based on the provided count.\n * @example\n * declension(1, ['slovo', 'slova', 'slov']) // 'slovo'\n * @example\n * declension(2, ['slovo', 'slova', 'slov']) // 'slova'\n * @example\n * declension(5, ['slovo', 'slova', 'slov']) // 'slov'\n */\nexport const declension = (\n  count: number,\n  txt: readonly [one: string, two: string, five: string],\n  cases = [2, 0, 1, 1, 1, 2],\n) =>\n  txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];\n\n/**\n * Splits text into lines with a maximum line length.\n */\nexport const splitTextByLines = (\n  text: string,\n  lineLingth: number = 60,\n): string[] => {\n  const words = text.split(/\\s+/).filter((word) => word !== '');\n  const lines = [];\n  let currentLine = '';\n\n  for (const word of words) {\n    if (word.length > lineLingth) {\n      if (currentLine !== '') {\n        lines.push(currentLine);\n        currentLine = '';\n      }\n\n      let start = 0;\n      while (start < word.length) {\n        const chunk = word.slice(start, start + lineLingth);\n        lines.push(chunk);\n        start += lineLingth;\n      }\n      continue;\n    }\n\n    // Проверка возможности добавления слова в текущую строку\n    if (currentLine === '') {\n      currentLine = word;\n    } else if (currentLine.length + 1 + word.length <= lineLingth) {\n      currentLine += ` ${word}`;\n    } else {\n      lines.push(currentLine);\n      currentLine = word;\n    }\n  }\n\n  if (currentLine !== '' || lines.length === 0) {\n    lines.push(currentLine);\n  }\n\n  return lines;\n};\n"],"names":[],"mappings":";;AASO,MAAM,aAAa,CACxB,OACA,KACA,QAAQ,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,MAEzB,IAAI,QAAQ,MAAM,KAAK,QAAQ,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,QAAQ,IAAI,CAAC,CAAC,CAAC;AAKvE,MAAM,mBAAmB,CAC9B,MACA,aAAqB,OACR;AACb,QAAM,QAAQ,KAAK,MAAM,KAAK,EAAE,OAAO,CAAC,SAAS,SAAS,EAAE;AAC5D,QAAM,QAAQ,CAAA;AACd,MAAI,cAAc;AAElB,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,YAAY;AAC5B,UAAI,gBAAgB,IAAI;AACtB,cAAM,KAAK,WAAW;AACtB,sBAAc;AAAA,MAChB;AAEA,UAAI,QAAQ;AACZ,aAAO,QAAQ,KAAK,QAAQ;AAC1B,cAAM,QAAQ,KAAK,MAAM,OAAO,QAAQ,UAAU;AAClD,cAAM,KAAK,KAAK;AAChB,iBAAS;AAAA,MACX;AACA;AAAA,IACF;AAGA,QAAI,gBAAgB,IAAI;AACtB,oBAAc;AAAA,IAChB,WAAW,YAAY,SAAS,IAAI,KAAK,UAAU,YAAY;AAC7D,qBAAe,IAAI,IAAI;AAAA,IACzB,OAAO;AACL,YAAM,KAAK,WAAW;AACtB,oBAAc;AAAA,IAChB;AAAA,EACF;AAEA,MAAI,gBAAgB,MAAM,MAAM,WAAW,GAAG;AAC5C,UAAM,KAAK,WAAW;AAAA,EACxB;AAEA,SAAO;AACT;;;"}
+{"version":3,"file":"text.cjs","names":[],"sources":["../src/text.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/text\n *\n * ## Description\n *\n * Russian-centric text helpers: **declension** by count (одно слово / два слова / пять слов) and\n * utilities for splitting long strings into wrapped lines. Pair with `yummies/date-time` for\n * natural language timestamps and labels in Slavic locales.\n *\n * ## Usage\n *\n * ```ts\n * import { declension } from \"yummies/text\";\n * ```\n */\n\n/**\n * Returns the correct word form based on the provided count.\n * @example\n * declension(1, ['slovo', 'slova', 'slov']) // 'slovo'\n * @example\n * declension(2, ['slovo', 'slova', 'slov']) // 'slova'\n * @example\n * declension(5, ['slovo', 'slova', 'slov']) // 'slov'\n */\nexport const declension = (\n  count: number,\n  txt: readonly [one: string, two: string, five: string],\n  cases = [2, 0, 1, 1, 1, 2],\n) =>\n  txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];\n\n/**\n * Splits text into lines with a maximum line length.\n */\nexport const splitTextByLines = (\n  text: string,\n  lineLingth: number = 60,\n): string[] => {\n  const words = text.split(/\\s+/).filter((word) => word !== '');\n  const lines = [];\n  let currentLine = '';\n\n  for (const word of words) {\n    if (word.length > lineLingth) {\n      if (currentLine !== '') {\n        lines.push(currentLine);\n        currentLine = '';\n      }\n\n      let start = 0;\n      while (start < word.length) {\n        const chunk = word.slice(start, start + lineLingth);\n        lines.push(chunk);\n        start += lineLingth;\n      }\n      continue;\n    }\n\n    // Проверка возможности добавления слова в текущую строку\n    if (currentLine === '') {\n      currentLine = word;\n    } else if (currentLine.length + 1 + word.length <= lineLingth) {\n      currentLine += ` ${word}`;\n    } else {\n      lines.push(currentLine);\n      currentLine = word;\n    }\n  }\n\n  if (currentLine !== '' || lines.length === 0) {\n    lines.push(currentLine);\n  }\n\n  return lines;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,cACX,OACA,KACA,QAAQ;CAAC;CAAG;CAAG;CAAG;CAAG;CAAG;CAAE,KAE1B,IAAI,QAAQ,MAAM,KAAK,QAAQ,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,QAAQ,IAAI,EAAE;;;;AAK7E,IAAa,oBACX,MACA,aAAqB,OACR;CACb,MAAM,QAAQ,KAAK,MAAM,MAAM,CAAC,QAAQ,SAAS,SAAS,GAAG;CAC7D,MAAM,QAAQ,EAAE;CAChB,IAAI,cAAc;AAElB,MAAK,MAAM,QAAQ,OAAO;AACxB,MAAI,KAAK,SAAS,YAAY;AAC5B,OAAI,gBAAgB,IAAI;AACtB,UAAM,KAAK,YAAY;AACvB,kBAAc;;GAGhB,IAAI,QAAQ;AACZ,UAAO,QAAQ,KAAK,QAAQ;IAC1B,MAAM,QAAQ,KAAK,MAAM,OAAO,QAAQ,WAAW;AACnD,UAAM,KAAK,MAAM;AACjB,aAAS;;AAEX;;AAIF,MAAI,gBAAgB,GAClB,eAAc;WACL,YAAY,SAAS,IAAI,KAAK,UAAU,WACjD,gBAAe,IAAI;OACd;AACL,SAAM,KAAK,YAAY;AACvB,iBAAc;;;AAIlB,KAAI,gBAAgB,MAAM,MAAM,WAAW,EACzC,OAAM,KAAK,YAAY;AAGzB,QAAO"}

package/text.d.ts

@@ -1,3 +1,19 @@
+/**
+ * ---header-docs-section---
+ * # yummies/text
+ *
+ * ## Description
+ *
+ * Russian-centric text helpers: **declension** by count (одно слово / два слова / пять слов) and
+ * utilities for splitting long strings into wrapped lines. Pair with `yummies/date-time` for
+ * natural language timestamps and labels in Slavic locales.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { declension } from "yummies/text";
+ * ```
+ */
 /**
  * Returns the correct word form based on the provided count.
  * @example

package/text.js

@@ -1,38 +1,69 @@
-const declension = (count, txt, cases = [2, 0, 1, 1, 1, 2]) => txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];
-const splitTextByLines = (text, lineLingth = 60) => {
-  const words = text.split(/\s+/).filter((word) => word !== "");
-  const lines = [];
-  let currentLine = "";
-  for (const word of words) {
-    if (word.length > lineLingth) {
-      if (currentLine !== "") {
-        lines.push(currentLine);
-        currentLine = "";
-      }
-      let start = 0;
-      while (start < word.length) {
-        const chunk = word.slice(start, start + lineLingth);
-        lines.push(chunk);
-        start += lineLingth;
-      }
-      continue;
-    }
-    if (currentLine === "") {
-      currentLine = word;
-    } else if (currentLine.length + 1 + word.length <= lineLingth) {
-      currentLine += ` ${word}`;
-    } else {
-      lines.push(currentLine);
-      currentLine = word;
-    }
-  }
-  if (currentLine !== "" || lines.length === 0) {
-    lines.push(currentLine);
-  }
-  return lines;
+//#region src/text.ts
+/**
+* ---header-docs-section---
+* # yummies/text
+*
+* ## Description
+*
+* Russian-centric text helpers: **declension** by count (одно слово / два слова / пять слов) and
+* utilities for splitting long strings into wrapped lines. Pair with `yummies/date-time` for
+* natural language timestamps and labels in Slavic locales.
+*
+* ## Usage
+*
+* ```ts
+* import { declension } from "yummies/text";
+* ```
+*/
+/**
+* Returns the correct word form based on the provided count.
+* @example
+* declension(1, ['slovo', 'slova', 'slov']) // 'slovo'
+* @example
+* declension(2, ['slovo', 'slova', 'slov']) // 'slova'
+* @example
+* declension(5, ['slovo', 'slova', 'slov']) // 'slov'
+*/
+var declension = (count, txt, cases = [
+	2,
+	0,
+	1,
+	1,
+	1,
+	2
+]) => txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];
+/**
+* Splits text into lines with a maximum line length.
+*/
+var splitTextByLines = (text, lineLingth = 60) => {
+	const words = text.split(/\s+/).filter((word) => word !== "");
+	const lines = [];
+	let currentLine = "";
+	for (const word of words) {
+		if (word.length > lineLingth) {
+			if (currentLine !== "") {
+				lines.push(currentLine);
+				currentLine = "";
+			}
+			let start = 0;
+			while (start < word.length) {
+				const chunk = word.slice(start, start + lineLingth);
+				lines.push(chunk);
+				start += lineLingth;
+			}
+			continue;
+		}
+		if (currentLine === "") currentLine = word;
+		else if (currentLine.length + 1 + word.length <= lineLingth) currentLine += ` ${word}`;
+		else {
+			lines.push(currentLine);
+			currentLine = word;
+		}
+	}
+	if (currentLine !== "" || lines.length === 0) lines.push(currentLine);
+	return lines;
 };
-export {
-  declension,
-  splitTextByLines
-};
-//# sourceMappingURL=text.js.map
+//#endregion
+export { declension, splitTextByLines };
+
+//# sourceMappingURL=text.js.map

package/text.js.map

@@ -1 +1 @@
-{"version":3,"file":"text.js","sources":["../src/text.ts"],"sourcesContent":["/**\n * Returns the correct word form based on the provided count.\n * @example\n * declension(1, ['slovo', 'slova', 'slov']) // 'slovo'\n * @example\n * declension(2, ['slovo', 'slova', 'slov']) // 'slova'\n * @example\n * declension(5, ['slovo', 'slova', 'slov']) // 'slov'\n */\nexport const declension = (\n  count: number,\n  txt: readonly [one: string, two: string, five: string],\n  cases = [2, 0, 1, 1, 1, 2],\n) =>\n  txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];\n\n/**\n * Splits text into lines with a maximum line length.\n */\nexport const splitTextByLines = (\n  text: string,\n  lineLingth: number = 60,\n): string[] => {\n  const words = text.split(/\\s+/).filter((word) => word !== '');\n  const lines = [];\n  let currentLine = '';\n\n  for (const word of words) {\n    if (word.length > lineLingth) {\n      if (currentLine !== '') {\n        lines.push(currentLine);\n        currentLine = '';\n      }\n\n      let start = 0;\n      while (start < word.length) {\n        const chunk = word.slice(start, start + lineLingth);\n        lines.push(chunk);\n        start += lineLingth;\n      }\n      continue;\n    }\n\n    // Проверка возможности добавления слова в текущую строку\n    if (currentLine === '') {\n      currentLine = word;\n    } else if (currentLine.length + 1 + word.length <= lineLingth) {\n      currentLine += ` ${word}`;\n    } else {\n      lines.push(currentLine);\n      currentLine = word;\n    }\n  }\n\n  if (currentLine !== '' || lines.length === 0) {\n    lines.push(currentLine);\n  }\n\n  return lines;\n};\n"],"names":[],"mappings":"AASO,MAAM,aAAa,CACxB,OACA,KACA,QAAQ,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,MAEzB,IAAI,QAAQ,MAAM,KAAK,QAAQ,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,QAAQ,IAAI,CAAC,CAAC,CAAC;AAKvE,MAAM,mBAAmB,CAC9B,MACA,aAAqB,OACR;AACb,QAAM,QAAQ,KAAK,MAAM,KAAK,EAAE,OAAO,CAAC,SAAS,SAAS,EAAE;AAC5D,QAAM,QAAQ,CAAA;AACd,MAAI,cAAc;AAElB,aAAW,QAAQ,OAAO;AACxB,QAAI,KAAK,SAAS,YAAY;AAC5B,UAAI,gBAAgB,IAAI;AACtB,cAAM,KAAK,WAAW;AACtB,sBAAc;AAAA,MAChB;AAEA,UAAI,QAAQ;AACZ,aAAO,QAAQ,KAAK,QAAQ;AAC1B,cAAM,QAAQ,KAAK,MAAM,OAAO,QAAQ,UAAU;AAClD,cAAM,KAAK,KAAK;AAChB,iBAAS;AAAA,MACX;AACA;AAAA,IACF;AAGA,QAAI,gBAAgB,IAAI;AACtB,oBAAc;AAAA,IAChB,WAAW,YAAY,SAAS,IAAI,KAAK,UAAU,YAAY;AAC7D,qBAAe,IAAI,IAAI;AAAA,IACzB,OAAO;AACL,YAAM,KAAK,WAAW;AACtB,oBAAc;AAAA,IAChB;AAAA,EACF;AAEA,MAAI,gBAAgB,MAAM,MAAM,WAAW,GAAG;AAC5C,UAAM,KAAK,WAAW;AAAA,EACxB;AAEA,SAAO;AACT;"}
+{"version":3,"file":"text.js","names":[],"sources":["../src/text.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/text\n *\n * ## Description\n *\n * Russian-centric text helpers: **declension** by count (одно слово / два слова / пять слов) and\n * utilities for splitting long strings into wrapped lines. Pair with `yummies/date-time` for\n * natural language timestamps and labels in Slavic locales.\n *\n * ## Usage\n *\n * ```ts\n * import { declension } from \"yummies/text\";\n * ```\n */\n\n/**\n * Returns the correct word form based on the provided count.\n * @example\n * declension(1, ['slovo', 'slova', 'slov']) // 'slovo'\n * @example\n * declension(2, ['slovo', 'slova', 'slov']) // 'slova'\n * @example\n * declension(5, ['slovo', 'slova', 'slov']) // 'slov'\n */\nexport const declension = (\n  count: number,\n  txt: readonly [one: string, two: string, five: string],\n  cases = [2, 0, 1, 1, 1, 2],\n) =>\n  txt[count % 100 > 4 && count % 100 < 20 ? 2 : cases[Math.min(count % 10, 5)]];\n\n/**\n * Splits text into lines with a maximum line length.\n */\nexport const splitTextByLines = (\n  text: string,\n  lineLingth: number = 60,\n): string[] => {\n  const words = text.split(/\\s+/).filter((word) => word !== '');\n  const lines = [];\n  let currentLine = '';\n\n  for (const word of words) {\n    if (word.length > lineLingth) {\n      if (currentLine !== '') {\n        lines.push(currentLine);\n        currentLine = '';\n      }\n\n      let start = 0;\n      while (start < word.length) {\n        const chunk = word.slice(start, start + lineLingth);\n        lines.push(chunk);\n        start += lineLingth;\n      }\n      continue;\n    }\n\n    // Проверка возможности добавления слова в текущую строку\n    if (currentLine === '') {\n      currentLine = word;\n    } else if (currentLine.length + 1 + word.length <= lineLingth) {\n      currentLine += ` ${word}`;\n    } else {\n      lines.push(currentLine);\n      currentLine = word;\n    }\n  }\n\n  if (currentLine !== '' || lines.length === 0) {\n    lines.push(currentLine);\n  }\n\n  return lines;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,cACX,OACA,KACA,QAAQ;CAAC;CAAG;CAAG;CAAG;CAAG;CAAG;CAAE,KAE1B,IAAI,QAAQ,MAAM,KAAK,QAAQ,MAAM,KAAK,IAAI,MAAM,KAAK,IAAI,QAAQ,IAAI,EAAE;;;;AAK7E,IAAa,oBACX,MACA,aAAqB,OACR;CACb,MAAM,QAAQ,KAAK,MAAM,MAAM,CAAC,QAAQ,SAAS,SAAS,GAAG;CAC7D,MAAM,QAAQ,EAAE;CAChB,IAAI,cAAc;AAElB,MAAK,MAAM,QAAQ,OAAO;AACxB,MAAI,KAAK,SAAS,YAAY;AAC5B,OAAI,gBAAgB,IAAI;AACtB,UAAM,KAAK,YAAY;AACvB,kBAAc;;GAGhB,IAAI,QAAQ;AACZ,UAAO,QAAQ,KAAK,QAAQ;IAC1B,MAAM,QAAQ,KAAK,MAAM,OAAO,QAAQ,WAAW;AACnD,UAAM,KAAK,MAAM;AACjB,aAAS;;AAEX;;AAIF,MAAI,gBAAgB,GAClB,eAAc;WACL,YAAY,SAAS,IAAI,KAAK,UAAU,WACjD,gBAAe,IAAI;OACd;AACL,SAAM,KAAK,YAAY;AACvB,iBAAc;;;AAIlB,KAAI,gBAAgB,MAAM,MAAM,WAAW,EACzC,OAAM,KAAK,YAAY;AAGzB,QAAO"}

package/type-guard.cjs

@@ -1,76 +1,296 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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"
+//#region src/type-guard/_exports.ts
+var _exports_exports = /* @__PURE__ */ require("./chunk-CVq3Gv4J.cjs").__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" }));
-exports.typeGuard = _exports;
-//# sourceMappingURL=type-guard.cjs.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
+Object.defineProperty(exports, "typeGuard", {
+	enumerable: true,
+	get: function() {
+		return _exports_exports;
+	}
+});
+
+//# sourceMappingURL=type-guard.cjs.map