@ocavue/utils 0.6.0 → 0.8.1

package/dist/index.d.ts

@@ -1,8 +1,10 @@
+//#region src/checker.d.ts
 /**
  * Checks if the given value is an object.
  */
 declare function isObject(value: unknown): value is Record<string | symbol | number, unknown>;
-
+//#endregion
+//#region src/dom.d.ts
 /**
  * Checks if the given DOM node is an Element.
  */
@@ -61,7 +63,22 @@ declare function getDocument(target?: Element | Window | Node | Document | null)
  * Gets a reference to the root node of the document based on the given target.
  */
 declare function getDocumentElement(target?: Element | Node | Window | Document | null): HTMLElement;
-
+//#endregion
+//#region src/format-bytes.d.ts
+/**
+ * Formats a number of bytes into a human-readable string.
+ * @param bytes - The number of bytes to format.
+ * @returns A string representing the number of bytes in a human-readable format.
+ */
+declare function formatBytes(bytes: number): string;
+//#endregion
+//#region src/get-id.d.ts
+/**
+ * Generates a unique positive integer.
+ */
+declare function getId(): number;
+//#endregion
+//#region src/once.d.ts
 /**
  * Creates a function that will only execute the provided function once.
  * Subsequent calls will return the cached result from the first execution.
@@ -76,12 +93,12 @@ declare function getDocumentElement(target?: Element | Node | Window | Document
  * ```
  */
 declare function once<T>(fn: () => T): () => T;
-
+//#endregion
+//#region src/sleep.d.ts
 /**
- * Formats a number of bytes into a human-readable string.
- * @param bytes - The number of bytes to format.
- * @returns A string representing the number of bytes in a human-readable format.
+ * Sleep for a given number of milliseconds.
  */
-declare function formatBytes(bytes: number): string;
-
-export { formatBytes, getDocument, getDocumentElement, getWindow, isDocument, isDocumentFragment, isElement, isElementLike, isHTMLElement, isMathMLElement, isNodeLike, isObject, isSVGElement, isShadowRoot, isTextNode, isWindowLike, once };
+declare function sleep(ms: number): Promise<void>;
+//#endregion
+export { formatBytes, getDocument, getDocumentElement, getId, getWindow, isDocument, isDocumentFragment, isElement, isElementLike, isHTMLElement, isMathMLElement, isNodeLike, isObject, isSVGElement, isShadowRoot, isTextNode, isWindowLike, once, sleep };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/checker.ts","../src/dom.ts","../src/format-bytes.ts","../src/get-id.ts","../src/once.ts","../src/sleep.ts"],"sourcesContent":[],"mappings":";;AAGA;;iBAAgB,QAAA,2BAEJ;;;;AAFZ;;iBCGgB,SAAA,OAAgB,eAAe;;AAA/C;AAOA;AAOgB,iBAPA,UAAA,CAOoB,IAAe,EAPlB,IAOkB,CAAA,EAAA,IAAW,IAPd,IAOc;AAO9D;AAOA;AAUA;AAOgB,iBA/BA,aAAA,CA+ByB,IAAe,EA/BpB,IA+BoB,CAAA,EAAA,IAAA,IA/BL,WA+BqB;AAOxE;AAOA;AAOA;AAWgB,iBAxDA,YAAA,CAwDuC,IAAM,EAxD1B,IAwD0B,CAAA,EAAA,IAAA,IAxDX,UAwDW;AAQ7D;;;AAC+B,iBA1Df,eAAA,CA0De,IAAA,EA1DO,IA0DP,CAAA,EAAA,IAAA,IA1DsB,aA0DtB;;;;AAoBf,iBApEA,UAAA,CAoEW,IAAA,EApEM,IAoEN,CAAA,EAAA,IAAA,IApEqB,QAoErB;;;;AACU,iBA9DrB,kBAAA,CA8DqB,IAAA,EA9DI,IA8DJ,CAAA,EAAA,IAAA,IA9DmB,gBA8DnB;;;AAiBrC;AACW,iBAzEK,YAAA,CAyEL,IAAA,EAzEwB,IAyExB,CAAA,EAAA,IAAA,IAzEuC,UAyEvC;;;;AACR,iBAnEa,UAAA,CAmEb,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAnEkD,IAmElD;;;;iBA5Da,aAAA,2BAAwC;ACnExD;;;iBD8EgB,YAAA,2BAAuC;AE9EvD;;;;ACQgB,iBH8EA,SAAA,CG9E6B,MAAA,CAAA,EH+ElC,IG/EkC,GH+E3B,UG/E2B,GH+Ed,QG/Ec,GAAA,IAAA,CAAA,EHgF1C,MGhF0C,GAAA,OHgF1B,UGhF0B;;;;ACV7C;iBJ6GgB,WAAA,UACL,UAAU,SAAS,OAAO,kBAClC;;;;iBAgBa,kBAAA,UACL,UAAU,OAAO,SAAS,kBAClC;;;;ADjIH;;;;ACGgB,iBCDA,WAAA,CDC+B,KAAO,EAAA,MAAA,CAAA,EAAA,MAAA;;;;ADHtD;;iBGEgB,KAAA,CAAA;;;;AHFhB;;;;ACGA;AAOA;AAOA;AAOA;AAOA;AAUA;AAOA;AAOA;AAOgB,iBGpDA,IHoDU,CAA2B,CAAA,CAAA,CAAA,EAAI,EAAA,GAAA,GGpDvB,CHoDuB,CAAA,EAAA,GAAA,GGpDb,CHoDa;;;;AD9DzD;;iBKAgB,KAAA,cAAmB"}

package/dist/index.js

@@ -1,114 +1,189 @@
-// src/checker.ts
+//#region src/checker.ts
+/**
+* Checks if the given value is an object.
+*/
 function isObject(value) {
-  return value != null && typeof value === "object";
+	return value != null && typeof value === "object";
 }
 
-// src/dom.ts
+//#endregion
+//#region src/dom-node-type.ts
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const DOCUMENT_NODE = 9;
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+//#endregion
+//#region src/dom.ts
+/**
+* Checks if the given DOM node is an Element.
+*/
 function isElement(node) {
-  return node.nodeType === 1 /* ELEMENT_NODE */;
+	return node.nodeType === ELEMENT_NODE;
 }
+/**
+* Checks if the given DOM node is a Text node.
+*/
 function isTextNode(node) {
-  return node.nodeType === 3 /* TEXT_NODE */;
+	return node.nodeType === TEXT_NODE;
 }
+/**
+* Checks if the given DOM node is an HTMLElement.
+*/
 function isHTMLElement(node) {
-  return isElement(node) && node.namespaceURI === "http://www.w3.org/1999/xhtml";
+	return isElement(node) && node.namespaceURI === "http://www.w3.org/1999/xhtml";
 }
+/**
+* Checks if the given DOM node is an SVGElement.
+*/
 function isSVGElement(node) {
-  return isElement(node) && node.namespaceURI === "http://www.w3.org/2000/svg";
+	return isElement(node) && node.namespaceURI === "http://www.w3.org/2000/svg";
 }
+/**
+* Checks if the given DOM node is an MathMLElement.
+*/
 function isMathMLElement(node) {
-  return isElement(node) && node.namespaceURI === "http://www.w3.org/1998/Math/MathML";
+	return isElement(node) && node.namespaceURI === "http://www.w3.org/1998/Math/MathML";
 }
+/**
+* Checks if the given DOM node is a Document.
+*/
 function isDocument(node) {
-  return node.nodeType === 9 /* DOCUMENT_NODE */;
+	return node.nodeType === DOCUMENT_NODE;
 }
+/**
+* Checks if the given DOM node is a DocumentFragment.
+*/
 function isDocumentFragment(node) {
-  return node.nodeType === 11 /* DOCUMENT_FRAGMENT_NODE */;
+	return node.nodeType === DOCUMENT_FRAGMENT_NODE;
 }
+/**
+* Checks if the given DOM node is a ShadowRoot.
+*/
 function isShadowRoot(node) {
-  return isDocumentFragment(node) && "host" in node && isElementLike(node.host);
+	return isDocumentFragment(node) && "host" in node && isElementLike(node.host);
 }
+/**
+* Checks if an unknown value is likely a DOM node.
+*/
 function isNodeLike(value) {
-  return isObject(value) && value.nodeType !== void 0;
+	return isObject(value) && value.nodeType !== void 0;
 }
+/**
+* Checks if an unknown value is likely a DOM element.
+*/
 function isElementLike(value) {
-  return isObject(value) && value.nodeType === 1 /* ELEMENT_NODE */ && typeof value.nodeName === "string";
+	return isObject(value) && value.nodeType === ELEMENT_NODE && typeof value.nodeName === "string";
 }
+/**
+* Checks if the given value is likely a Window object.
+*/
 function isWindowLike(value) {
-  return isObject(value) && value.window === value;
+	return isObject(value) && value.window === value;
 }
+/**
+* Gets the window object for the given target or the global window object if no
+* target is provided.
+*/
 function getWindow(target) {
-  if (target) {
-    if (isShadowRoot(target)) {
-      return getWindow(target.host);
-    }
-    if (isDocument(target)) {
-      return target.defaultView || window;
-    }
-    if (isElement(target)) {
-      return target.ownerDocument?.defaultView || window;
-    }
-  }
-  return window;
-}
+	if (target) {
+		if (isShadowRoot(target)) return getWindow(target.host);
+		if (isDocument(target)) return target.defaultView || window;
+		if (isElement(target)) return target.ownerDocument?.defaultView || window;
+	}
+	return window;
+}
+/**
+* Gets the document for the given target or the global document if no target is
+* provided.
+*/
 function getDocument(target) {
-  if (target) {
-    if (isWindowLike(target)) {
-      return target.document;
-    }
-    if (isDocument(target)) {
-      return target;
-    }
-    return target.ownerDocument || document;
-  }
-  return document;
-}
+	if (target) {
+		if (isWindowLike(target)) return target.document;
+		if (isDocument(target)) return target;
+		return target.ownerDocument || document;
+	}
+	return document;
+}
+/**
+* Gets a reference to the root node of the document based on the given target.
+*/
 function getDocumentElement(target) {
-  return getDocument(target).documentElement;
+	return getDocument(target).documentElement;
+}
+
+//#endregion
+//#region src/format-bytes.ts
+/**
+* Formats a number of bytes into a human-readable string.
+* @param bytes - The number of bytes to format.
+* @returns A string representing the number of bytes in a human-readable format.
+*/
+function formatBytes(bytes) {
+	const units = [
+		"B",
+		"KB",
+		"MB",
+		"GB"
+	];
+	let unitIndex = 0;
+	let num = bytes;
+	while (Math.abs(num) >= 1024 && unitIndex < units.length - 1) {
+		num /= 1024;
+		unitIndex++;
+	}
+	const fraction = unitIndex === 0 && num % 1 === 0 ? 0 : 1;
+	return `${num.toFixed(fraction)}${units[unitIndex]}`;
 }
 
-// src/once.ts
+//#endregion
+//#region src/get-id.ts
+let id = 0;
+/**
+* Generates a unique positive integer.
+*/
+function getId() {
+	id = id % Number.MAX_SAFE_INTEGER + 1;
+	return id;
+}
+
+//#endregion
+//#region src/once.ts
+/**
+* Creates a function that will only execute the provided function once.
+* Subsequent calls will return the cached result from the first execution.
+*
+* @param fn The function to execute once
+* @returns A function that will only execute the provided function once
+* @example
+* ```ts
+* const getValue = once(() => expensiveOperation())
+* getValue() // executes expensiveOperation
+* getValue() // returns cached result
+* ```
+*/
 function once(fn) {
-  let called = false;
-  let result;
-  return () => {
-    if (!called) {
-      result = fn();
-      called = true;
-      fn = void 0;
-    }
-    return result;
-  };
+	let called = false;
+	let result;
+	return () => {
+		if (!called) {
+			result = fn();
+			called = true;
+			fn = void 0;
+		}
+		return result;
+	};
 }
 
-// src/format-bytes.ts
-function formatBytes(bytes) {
-  const units = ["B", "KB", "MB", "GB"];
-  let unitIndex = 0;
-  let num = bytes;
-  while (Math.abs(num) >= 1024 && unitIndex < units.length - 1) {
-    num /= 1024;
-    unitIndex++;
-  }
-  const fraction = unitIndex === 0 && num % 1 === 0 ? 0 : 1;
-  return `${num.toFixed(fraction)}${units[unitIndex]}`;
-}
-export {
-  formatBytes,
-  getDocument,
-  getDocumentElement,
-  getWindow,
-  isDocument,
-  isDocumentFragment,
-  isElement,
-  isElementLike,
-  isHTMLElement,
-  isMathMLElement,
-  isNodeLike,
-  isObject,
-  isSVGElement,
-  isShadowRoot,
-  isTextNode,
-  isWindowLike,
-  once
-};
+//#endregion
+//#region src/sleep.ts
+/**
+* Sleep for a given number of milliseconds.
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { formatBytes, getDocument, getDocumentElement, getId, getWindow, isDocument, isDocumentFragment, isElement, isElementLike, isHTMLElement, isMathMLElement, isNodeLike, isObject, isSVGElement, isShadowRoot, isTextNode, isWindowLike, once, sleep };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["NodeType.ELEMENT_NODE","NodeType.TEXT_NODE","NodeType.DOCUMENT_NODE","NodeType.DOCUMENT_FRAGMENT_NODE","result: T"],"sources":["../src/checker.ts","../src/dom-node-type.ts","../src/dom.ts","../src/format-bytes.ts","../src/get-id.ts","../src/once.ts","../src/sleep.ts"],"sourcesContent":["/**\n * Checks if the given value is an object.\n */\nexport function isObject(\n  value: unknown,\n): value is Record<string | symbol | number, unknown> {\n  return value != null && typeof value === 'object'\n}\n","// prettier-ignore\nexport const ELEMENT_NODE = 1 satisfies typeof Node.ELEMENT_NODE;\n// prettier-ignore\nexport const ATTRIBUTE_NODE = 2 satisfies typeof Node.ATTRIBUTE_NODE;\n// prettier-ignore\nexport const TEXT_NODE = 3 satisfies typeof Node.TEXT_NODE;\n// prettier-ignore\nexport const CDATA_SECTION_NODE = 4 satisfies typeof Node.CDATA_SECTION_NODE;\n// prettier-ignore\nexport const ENTITY_REFERENCE_NODE = 5 satisfies typeof Node.ENTITY_REFERENCE_NODE;\n// prettier-ignore\nexport const ENTITY_NODE = 6 satisfies typeof Node.ENTITY_NODE;\n// prettier-ignore\nexport const PROCESSING_INSTRUCTION_NODE = 7 satisfies typeof Node.PROCESSING_INSTRUCTION_NODE;\n// prettier-ignore\nexport const COMMENT_NODE = 8 satisfies typeof Node.COMMENT_NODE;\n// prettier-ignore\nexport const DOCUMENT_NODE = 9 satisfies typeof Node.DOCUMENT_NODE;\n// prettier-ignore\nexport const DOCUMENT_TYPE_NODE = 10 satisfies typeof Node.DOCUMENT_TYPE_NODE;\n// prettier-ignore\nexport const DOCUMENT_FRAGMENT_NODE = 11 satisfies typeof Node.DOCUMENT_FRAGMENT_NODE;\n// prettier-ignore\nexport const NOTATION_NODE = 12 satisfies typeof Node.NOTATION_NODE;\n","import { isObject } from './checker'\nimport * as NodeType from './dom-node-type'\n\n/**\n * Checks if the given DOM node is an Element.\n */\nexport function isElement(node: Node): node is Element {\n  return node.nodeType === NodeType.ELEMENT_NODE\n}\n\n/**\n * Checks if the given DOM node is a Text node.\n */\nexport function isTextNode(node: Node): node is Text {\n  return node.nodeType === NodeType.TEXT_NODE\n}\n\n/**\n * Checks if the given DOM node is an HTMLElement.\n */\nexport function isHTMLElement(node: Node): node is HTMLElement {\n  return isElement(node) && node.namespaceURI === 'http://www.w3.org/1999/xhtml'\n}\n\n/**\n * Checks if the given DOM node is an SVGElement.\n */\nexport function isSVGElement(node: Node): node is SVGElement {\n  return isElement(node) && node.namespaceURI === 'http://www.w3.org/2000/svg'\n}\n\n/**\n * Checks if the given DOM node is an MathMLElement.\n */\nexport function isMathMLElement(node: Node): node is MathMLElement {\n  return (\n    isElement(node) &&\n    node.namespaceURI === 'http://www.w3.org/1998/Math/MathML'\n  )\n}\n\n/**\n * Checks if the given DOM node is a Document.\n */\nexport function isDocument(node: Node): node is Document {\n  return node.nodeType === NodeType.DOCUMENT_NODE\n}\n\n/**\n * Checks if the given DOM node is a DocumentFragment.\n */\nexport function isDocumentFragment(node: Node): node is DocumentFragment {\n  return node.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE\n}\n\n/**\n * Checks if the given DOM node is a ShadowRoot.\n */\nexport function isShadowRoot(node: Node): node is ShadowRoot {\n  return isDocumentFragment(node) && 'host' in node && isElementLike(node.host)\n}\n\n/**\n * Checks if an unknown value is likely a DOM node.\n */\nexport function isNodeLike(value: unknown): value is Node {\n  return isObject(value) && value.nodeType !== undefined\n}\n\n/**\n * Checks if an unknown value is likely a DOM element.\n */\nexport function isElementLike(value: unknown): value is Element {\n  return (\n    isObject(value) &&\n    value.nodeType === NodeType.ELEMENT_NODE &&\n    typeof value.nodeName === 'string'\n  )\n}\n\n/**\n * Checks if the given value is likely a Window object.\n */\nexport function isWindowLike(value: unknown): value is Window {\n  return isObject(value) && value.window === value\n}\n\n/**\n * Gets the window object for the given target or the global window object if no\n * target is provided.\n */\nexport function getWindow(\n  target?: Node | ShadowRoot | Document | null,\n): Window & typeof globalThis {\n  if (target) {\n    if (isShadowRoot(target)) {\n      return getWindow(target.host)\n    }\n    if (isDocument(target)) {\n      return target.defaultView || window\n    }\n    if (isElement(target)) {\n      return target.ownerDocument?.defaultView || window\n    }\n  }\n  return window\n}\n\n/**\n * Gets the document for the given target or the global document if no target is\n * provided.\n */\nexport function getDocument(\n  target?: Element | Window | Node | Document | null,\n): Document {\n  if (target) {\n    if (isWindowLike(target)) {\n      return target.document\n    }\n    if (isDocument(target)) {\n      return target\n    }\n    return target.ownerDocument || document\n  }\n  return document\n}\n\n/**\n * Gets a reference to the root node of the document based on the given target.\n */\nexport function getDocumentElement(\n  target?: Element | Node | Window | Document | null,\n): HTMLElement {\n  return getDocument(target).documentElement\n}\n","/**\n * Formats a number of bytes into a human-readable string.\n * @param bytes - The number of bytes to format.\n * @returns A string representing the number of bytes in a human-readable format.\n */\nexport function formatBytes(bytes: number): string {\n  const units = ['B', 'KB', 'MB', 'GB']\n  let unitIndex = 0\n  let num = bytes\n  while (Math.abs(num) >= 1024 && unitIndex < units.length - 1) {\n    num /= 1024\n    unitIndex++\n  }\n  const fraction = unitIndex === 0 && num % 1 === 0 ? 0 : 1\n  return `${num.toFixed(fraction)}${units[unitIndex]}`\n}\n","let id = 0\n\n/**\n * Generates a unique positive integer.\n */\nexport function getId(): number {\n  id = (id % Number.MAX_SAFE_INTEGER) + 1\n  return id\n}\n","/**\n * Creates a function that will only execute the provided function once.\n * Subsequent calls will return the cached result from the first execution.\n *\n * @param fn The function to execute once\n * @returns A function that will only execute the provided function once\n * @example\n * ```ts\n * const getValue = once(() => expensiveOperation())\n * getValue() // executes expensiveOperation\n * getValue() // returns cached result\n * ```\n */\nexport function once<T>(fn: () => T): () => T {\n  let called = false\n  let result: T\n  return () => {\n    if (!called) {\n      result = fn()\n      called = true\n      // @ts-expect-error - micro-optimization for memory management\n      fn = undefined\n    }\n    return result\n  }\n}\n","/**\n * Sleep for a given number of milliseconds.\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n"],"mappings":";;;;AAGA,SAAgB,SACd,OACoD;AACpD,QAAO,SAAS,QAAQ,OAAO,UAAU;;;;;ACL3C,MAAa,eAAe;AAI5B,MAAa,YAAY;AAYzB,MAAa,gBAAgB;AAI7B,MAAa,yBAAyB;;;;;;;ACftC,SAAgB,UAAU,MAA6B;AACrD,QAAO,KAAK,aAAaA;;;;;AAM3B,SAAgB,WAAW,MAA0B;AACnD,QAAO,KAAK,aAAaC;;;;;AAM3B,SAAgB,cAAc,MAAiC;AAC7D,QAAO,UAAU,KAAK,IAAI,KAAK,iBAAiB;;;;;AAMlD,SAAgB,aAAa,MAAgC;AAC3D,QAAO,UAAU,KAAK,IAAI,KAAK,iBAAiB;;;;;AAMlD,SAAgB,gBAAgB,MAAmC;AACjE,QACE,UAAU,KAAK,IACf,KAAK,iBAAiB;;;;;AAO1B,SAAgB,WAAW,MAA8B;AACvD,QAAO,KAAK,aAAaC;;;;;AAM3B,SAAgB,mBAAmB,MAAsC;AACvE,QAAO,KAAK,aAAaC;;;;;AAM3B,SAAgB,aAAa,MAAgC;AAC3D,QAAO,mBAAmB,KAAK,IAAI,UAAU,QAAQ,cAAc,KAAK,KAAK;;;;;AAM/E,SAAgB,WAAW,OAA+B;AACxD,QAAO,SAAS,MAAM,IAAI,MAAM,aAAa;;;;;AAM/C,SAAgB,cAAc,OAAkC;AAC9D,QACE,SAAS,MAAM,IACf,MAAM,aAAaH,gBACnB,OAAO,MAAM,aAAa;;;;;AAO9B,SAAgB,aAAa,OAAiC;AAC5D,QAAO,SAAS,MAAM,IAAI,MAAM,WAAW;;;;;;AAO7C,SAAgB,UACd,QAC4B;AAC5B,KAAI,QAAQ;AACV,MAAI,aAAa,OAAO,CACtB,QAAO,UAAU,OAAO,KAAK;AAE/B,MAAI,WAAW,OAAO,CACpB,QAAO,OAAO,eAAe;AAE/B,MAAI,UAAU,OAAO,CACnB,QAAO,OAAO,eAAe,eAAe;;AAGhD,QAAO;;;;;;AAOT,SAAgB,YACd,QACU;AACV,KAAI,QAAQ;AACV,MAAI,aAAa,OAAO,CACtB,QAAO,OAAO;AAEhB,MAAI,WAAW,OAAO,CACpB,QAAO;AAET,SAAO,OAAO,iBAAiB;;AAEjC,QAAO;;;;;AAMT,SAAgB,mBACd,QACa;AACb,QAAO,YAAY,OAAO,CAAC;;;;;;;;;;AChI7B,SAAgB,YAAY,OAAuB;CACjD,MAAM,QAAQ;EAAC;EAAK;EAAM;EAAM;EAAK;CACrC,IAAI,YAAY;CAChB,IAAI,MAAM;AACV,QAAO,KAAK,IAAI,IAAI,IAAI,QAAQ,YAAY,MAAM,SAAS,GAAG;AAC5D,SAAO;AACP;;CAEF,MAAM,WAAW,cAAc,KAAK,MAAM,MAAM,IAAI,IAAI;AACxD,QAAO,GAAG,IAAI,QAAQ,SAAS,GAAG,MAAM;;;;;ACd1C,IAAI,KAAK;;;;AAKT,SAAgB,QAAgB;AAC9B,MAAM,KAAK,OAAO,mBAAoB;AACtC,QAAO;;;;;;;;;;;;;;;;;;ACMT,SAAgB,KAAQ,IAAsB;CAC5C,IAAI,SAAS;CACb,IAAII;AACJ,cAAa;AACX,MAAI,CAAC,QAAQ;AACX,YAAS,IAAI;AACb,YAAS;AAET,QAAK;;AAEP,SAAO;;;;;;;;;ACpBX,SAAgB,MAAM,IAA2B;AAC/C,QAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@ocavue/utils",
   "type": "module",
-  "version": "0.6.0",
-  "description": "",
+  "version": "0.8.1",
+  "description": "A collection of utility functions for the browser and other environments",
   "author": "ocavue <ocavue@gmail.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/ocavue",
@@ -33,21 +33,23 @@
     }
   },
   "files": [
+    "src",
     "dist"
   ],
   "devDependencies": {
-    "@ocavue/eslint-config": "^3.2.0",
-    "@ocavue/tsconfig": "^0.3.7",
+    "@ocavue/eslint-config": "^3.6.1",
+    "@ocavue/tsconfig": "^0.5.0",
     "@size-limit/preset-small-lib": "^11.2.0",
-    "@types/node": "^20.17.27",
-    "eslint": "^9.31.0",
-    "jsdom": "^26.1.0",
+    "@types/node": "^24.9.2",
+    "@vitest/coverage-v8": "4.0.4",
+    "eslint": "^9.38.0",
+    "jsdom": "^27.0.1",
     "prettier": "^3.6.2",
     "size-limit": "^11.2.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5",
-    "vitest": "^3.2.4"
+    "tsdown": "^0.15.11",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.12",
+    "vitest": "^4.0.4"
   },
   "publishConfig": {
     "access": "public"
@@ -63,8 +65,8 @@
     ]
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "lint": "eslint .",
     "fix": "eslint --fix . && prettier --write .",
     "test": "vitest",

package/src/checker.test.ts

@@ -0,0 +1,40 @@
+// @vitest-environment node
+
+import { describe, expect, it } from 'vitest'
+
+import { isObject } from './checker'
+
+describe('isObject', () => {
+  it('returns true for plain objects', () => {
+    expect(isObject({})).toBe(true)
+    expect(isObject({ foo: 'bar' })).toBe(true)
+  })
+
+  it('returns true for arrays', () => {
+    expect(isObject([])).toBe(true)
+    expect(isObject(['foo'])).toBe(true)
+  })
+
+  it('returns false for null and undefined', () => {
+    expect(isObject(null)).toBe(false)
+    expect(isObject(undefined)).toBe(false)
+  })
+
+  it('returns false for primitives', () => {
+    expect(isObject(42)).toBe(false)
+    expect(isObject(42n)).toBe(false)
+    expect(isObject(Number.NaN)).toBe(false)
+    expect(isObject(Infinity)).toBe(false)
+    expect(isObject(true)).toBe(false)
+    expect(isObject(false)).toBe(false)
+    expect(isObject(Symbol.iterator)).toBe(false)
+    expect(isObject(Symbol.for('foo'))).toBe(false)
+    expect(isObject(Symbol())).toBe(false)
+    expect(isObject('string')).toBe(false)
+  })
+
+  it('returns true for class instances', () => {
+    class TestClass {}
+    expect(isObject(new TestClass())).toBe(true)
+  })
+})

package/src/checker.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the given value is an object.
+ */
+export function isObject(
+  value: unknown,
+): value is Record<string | symbol | number, unknown> {
+  return value != null && typeof value === 'object'
+}

package/src/dom-node-type.ts

@@ -0,0 +1,24 @@
+// prettier-ignore
+export const ELEMENT_NODE = 1 satisfies typeof Node.ELEMENT_NODE;
+// prettier-ignore
+export const ATTRIBUTE_NODE = 2 satisfies typeof Node.ATTRIBUTE_NODE;
+// prettier-ignore
+export const TEXT_NODE = 3 satisfies typeof Node.TEXT_NODE;
+// prettier-ignore
+export const CDATA_SECTION_NODE = 4 satisfies typeof Node.CDATA_SECTION_NODE;
+// prettier-ignore
+export const ENTITY_REFERENCE_NODE = 5 satisfies typeof Node.ENTITY_REFERENCE_NODE;
+// prettier-ignore
+export const ENTITY_NODE = 6 satisfies typeof Node.ENTITY_NODE;
+// prettier-ignore
+export const PROCESSING_INSTRUCTION_NODE = 7 satisfies typeof Node.PROCESSING_INSTRUCTION_NODE;
+// prettier-ignore
+export const COMMENT_NODE = 8 satisfies typeof Node.COMMENT_NODE;
+// prettier-ignore
+export const DOCUMENT_NODE = 9 satisfies typeof Node.DOCUMENT_NODE;
+// prettier-ignore
+export const DOCUMENT_TYPE_NODE = 10 satisfies typeof Node.DOCUMENT_TYPE_NODE;
+// prettier-ignore
+export const DOCUMENT_FRAGMENT_NODE = 11 satisfies typeof Node.DOCUMENT_FRAGMENT_NODE;
+// prettier-ignore
+export const NOTATION_NODE = 12 satisfies typeof Node.NOTATION_NODE;

package/src/dom.test.ts

@@ -0,0 +1,255 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it } from 'vitest'
+
+import {
+  getDocument,
+  getDocumentElement,
+  getWindow,
+  isDocument,
+  isDocumentFragment,
+  isElement,
+  isElementLike,
+  isHTMLElement,
+  isMathMLElement,
+  isNodeLike,
+  isShadowRoot,
+  isSVGElement,
+  isTextNode,
+  isWindowLike,
+} from './dom'
+
+describe('isElement', () => {
+  it('can be used to check if a node is an element', () => {
+    const div = document.createElement('div')
+    expect(isElement(div)).toBe(true)
+  })
+})
+
+describe('isTextNode', () => {
+  it('can be used to check if a node is a text node', () => {
+    const text = document.createTextNode('Hello, world!')
+    expect(isTextNode(text)).toBe(true)
+  })
+})
+
+describe('isHTMLElement', () => {
+  it('can be used to check if a node is an HTML element', () => {
+    const div = document.createElement('div')
+    expect(isHTMLElement(div)).toBe(true)
+  })
+})
+
+describe('isSVGElement', () => {
+  it('can be used to check if a node is an SVG element', () => {
+    const div = document.createElement('div')
+    div.innerHTML = `<svg><rect width="200" height="100" x="10" y="10" rx="20" ry="20" fill="blue" /></svg>`
+    expect(isSVGElement(div.firstChild!)).toBe(true)
+  })
+
+  it('returns false for non-SVG elements', () => {
+    const div = document.createElement('div')
+    expect(isSVGElement(div)).toBe(false)
+  })
+})
+
+describe('isMathMLElement', () => {
+  it('can be used to check if a node is a MathML element', () => {
+    const div = document.createElement('div')
+    div.innerHTML = `<math><mn>1</mn><mo>+</mo><mn>2</mn><mo>+</mo><mn>3</mn></math>`
+    expect(isMathMLElement(div.firstChild!)).toBe(true)
+  })
+
+  it('returns false for non-MathML elements', () => {
+    const div = document.createElement('div')
+    expect(isMathMLElement(div)).toBe(false)
+  })
+})
+
+describe('isElementLike', () => {
+  it('returns true for HTML elements', () => {
+    const div = document.createElement('div')
+    expect(isElementLike(div)).toBe(true)
+  })
+
+  it('returns true for SVG elements', () => {
+    const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
+    expect(isElementLike(svg)).toBe(true)
+  })
+
+  it('returns false for text nodes', () => {
+    const text = document.createTextNode('text')
+    expect(isElementLike(text)).toBe(false)
+  })
+
+  it('returns false for non-node values', () => {
+    expect(isElementLike({})).toBe(false)
+    expect(isElementLike(null)).toBe(false)
+    expect(isElementLike(undefined)).toBe(false)
+    expect(isElementLike('string')).toBe(false)
+    expect(isElementLike(123)).toBe(false)
+    expect(isElementLike(true)).toBe(false)
+    expect(isElementLike(() => 123)).toBe(false)
+  })
+})
+
+describe('isDocument', () => {
+  it('returns true for document', () => {
+    expect(isDocument(document)).toBe(true)
+  })
+
+  it('returns false for other nodes', () => {
+    const div = document.createElement('div')
+    expect(isDocument(div)).toBe(false)
+  })
+})
+
+describe('isDocumentFragment', () => {
+  it('returns true for document fragment', () => {
+    const fragment = document.createDocumentFragment()
+    expect(isDocumentFragment(fragment)).toBe(true)
+  })
+
+  it('returns false for other nodes', () => {
+    const div = document.createElement('div')
+    expect(isDocumentFragment(div)).toBe(false)
+  })
+})
+
+describe('isShadowRoot', () => {
+  it('returns true for shadow root', () => {
+    const div = document.createElement('div')
+    const shadowRoot = div.attachShadow({ mode: 'open' })
+    expect(isShadowRoot(shadowRoot)).toBe(true)
+  })
+
+  it('returns false for other nodes', () => {
+    const div = document.createElement('div')
+    expect(isShadowRoot(div)).toBe(false)
+  })
+})
+
+describe('isNodeLike', () => {
+  it('returns true for DOM nodes', () => {
+    const div = document.createElement('div')
+    expect(isNodeLike(div)).toBe(true)
+
+    const text = document.createTextNode('text')
+    expect(isNodeLike(text)).toBe(true)
+  })
+
+  it('returns false for non-node values', () => {
+    expect(isNodeLike({})).toBe(false)
+    expect(isNodeLike(null)).toBe(false)
+    expect(isNodeLike(undefined)).toBe(false)
+    expect(isNodeLike('string')).toBe(false)
+  })
+})
+
+describe('isWindowLike', () => {
+  it('returns true for window object', () => {
+    expect(isWindowLike(window)).toBe(true)
+  })
+
+  it('returns false for non-window values', () => {
+    const div = document.createElement('div')
+    expect(isWindowLike(div)).toBe(false)
+    expect(isWindowLike({})).toBe(false)
+    expect(isWindowLike(null)).toBe(false)
+  })
+})
+
+describe('getWindow', () => {
+  it('returns window when no target is provided', () => {
+    expect(getWindow()).toBe(window)
+  })
+
+  it('returns window for element', () => {
+    const div = document.createElement('div')
+    expect(getWindow(div)).toBe(window)
+  })
+
+  it('returns window for document', () => {
+    expect(getWindow(document)).toBe(window)
+  })
+
+  it('returns window for shadow root', () => {
+    const div = document.createElement('div')
+    const shadowRoot = div.attachShadow({ mode: 'open' })
+    expect(getWindow(shadowRoot)).toBe(window)
+  })
+
+  it('returns fallback window when document.defaultView is null', () => {
+    const doc = {} as Document
+    Object.defineProperty(doc, 'nodeType', { value: 9 }) // DOCUMENT_NODE
+    Object.defineProperty(doc, 'defaultView', { value: null })
+    expect(getWindow(doc)).toBe(window)
+  })
+
+  it('returns fallback window when element.ownerDocument is null', () => {
+    const el = {} as Element
+    Object.defineProperty(el, 'nodeType', { value: 1 }) // ELEMENT_NODE
+    Object.defineProperty(el, 'ownerDocument', { value: null })
+    expect(getWindow(el)).toBe(window)
+  })
+
+  it('returns fallback window when element.ownerDocument.defaultView is null', () => {
+    const doc = {} as Document
+    Object.defineProperty(doc, 'nodeType', { value: 9 }) // DOCUMENT_NODE
+    Object.defineProperty(doc, 'defaultView', { value: null })
+
+    const el = {} as Element
+    Object.defineProperty(el, 'nodeType', { value: 1 }) // ELEMENT_NODE
+    Object.defineProperty(el, 'ownerDocument', { value: doc })
+    expect(getWindow(el)).toBe(window)
+  })
+
+  it('returns window for text node', () => {
+    const text = document.createTextNode('hello')
+    expect(getWindow(text)).toBe(window)
+  })
+})
+
+describe('getDocument', () => {
+  it('returns document when no target is provided', () => {
+    expect(getDocument()).toBe(document)
+  })
+
+  it('returns document for window', () => {
+    expect(getDocument(window)).toBe(document)
+  })
+
+  it('returns document when passed a document', () => {
+    expect(getDocument(document)).toBe(document)
+  })
+
+  it('returns ownerDocument for element', () => {
+    const div = document.createElement('div')
+    expect(getDocument(div)).toBe(document)
+  })
+
+  it('returns fallback document when element.ownerDocument is null', () => {
+    const node = {} as Node
+    Object.defineProperty(node, 'ownerDocument', { value: null })
+    expect(getDocument(node)).toBe(document)
+  })
+})
+
+describe('getDocumentElement', () => {
+  it('returns documentElement when no target is provided', () => {
+    expect(getDocumentElement()).toBe(document.documentElement)
+  })
+
+  it('returns documentElement for element', () => {
+    const div = document.createElement('div')
+    expect(getDocumentElement(div)).toBe(document.documentElement)
+  })
+
+  it('returns documentElement for window', () => {
+    expect(getDocumentElement(window)).toBe(document.documentElement)
+  })
+
+  it('returns documentElement for document', () => {
+    expect(getDocumentElement(document)).toBe(document.documentElement)
+  })
+})

package/src/dom.ts

@@ -0,0 +1,135 @@
+import { isObject } from './checker'
+import * as NodeType from './dom-node-type'
+
+/**
+ * Checks if the given DOM node is an Element.
+ */
+export function isElement(node: Node): node is Element {
+  return node.nodeType === NodeType.ELEMENT_NODE
+}
+
+/**
+ * Checks if the given DOM node is a Text node.
+ */
+export function isTextNode(node: Node): node is Text {
+  return node.nodeType === NodeType.TEXT_NODE
+}
+
+/**
+ * Checks if the given DOM node is an HTMLElement.
+ */
+export function isHTMLElement(node: Node): node is HTMLElement {
+  return isElement(node) && node.namespaceURI === 'http://www.w3.org/1999/xhtml'
+}
+
+/**
+ * Checks if the given DOM node is an SVGElement.
+ */
+export function isSVGElement(node: Node): node is SVGElement {
+  return isElement(node) && node.namespaceURI === 'http://www.w3.org/2000/svg'
+}
+
+/**
+ * Checks if the given DOM node is an MathMLElement.
+ */
+export function isMathMLElement(node: Node): node is MathMLElement {
+  return (
+    isElement(node) &&
+    node.namespaceURI === 'http://www.w3.org/1998/Math/MathML'
+  )
+}
+
+/**
+ * Checks if the given DOM node is a Document.
+ */
+export function isDocument(node: Node): node is Document {
+  return node.nodeType === NodeType.DOCUMENT_NODE
+}
+
+/**
+ * Checks if the given DOM node is a DocumentFragment.
+ */
+export function isDocumentFragment(node: Node): node is DocumentFragment {
+  return node.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE
+}
+
+/**
+ * Checks if the given DOM node is a ShadowRoot.
+ */
+export function isShadowRoot(node: Node): node is ShadowRoot {
+  return isDocumentFragment(node) && 'host' in node && isElementLike(node.host)
+}
+
+/**
+ * Checks if an unknown value is likely a DOM node.
+ */
+export function isNodeLike(value: unknown): value is Node {
+  return isObject(value) && value.nodeType !== undefined
+}
+
+/**
+ * Checks if an unknown value is likely a DOM element.
+ */
+export function isElementLike(value: unknown): value is Element {
+  return (
+    isObject(value) &&
+    value.nodeType === NodeType.ELEMENT_NODE &&
+    typeof value.nodeName === 'string'
+  )
+}
+
+/**
+ * Checks if the given value is likely a Window object.
+ */
+export function isWindowLike(value: unknown): value is Window {
+  return isObject(value) && value.window === value
+}
+
+/**
+ * Gets the window object for the given target or the global window object if no
+ * target is provided.
+ */
+export function getWindow(
+  target?: Node | ShadowRoot | Document | null,
+): Window & typeof globalThis {
+  if (target) {
+    if (isShadowRoot(target)) {
+      return getWindow(target.host)
+    }
+    if (isDocument(target)) {
+      return target.defaultView || window
+    }
+    if (isElement(target)) {
+      return target.ownerDocument?.defaultView || window
+    }
+  }
+  return window
+}
+
+/**
+ * Gets the document for the given target or the global document if no target is
+ * provided.
+ */
+export function getDocument(
+  target?: Element | Window | Node | Document | null,
+): Document {
+  if (target) {
+    if (isWindowLike(target)) {
+      return target.document
+    }
+    if (isDocument(target)) {
+      return target
+    }
+    return target.ownerDocument || document
+  }
+  return document
+}
+
+/**
+ * Gets a reference to the root node of the document based on the given target.
+ */
+export function getDocumentElement(
+  target?: Element | Node | Window | Document | null,
+): HTMLElement {
+  return getDocument(target).documentElement
+}

package/src/format-bytes.test.ts

@@ -0,0 +1,58 @@
+// @vitest-environment node
+
+import { describe, expect, it } from 'vitest'
+
+import { formatBytes } from './format-bytes'
+
+describe('formatBytes', () => {
+  it('formats bytes correctly', () => {
+    expect(formatBytes(0)).toBe('0B')
+    expect(formatBytes(100)).toBe('100B')
+    expect(formatBytes(512)).toBe('512B')
+    expect(formatBytes(1023)).toBe('1023B')
+  })
+
+  it('formats kilobytes correctly', () => {
+    expect(formatBytes(1024)).toBe('1.0KB')
+    expect(formatBytes(1536)).toBe('1.5KB')
+    expect(formatBytes(2048)).toBe('2.0KB')
+    expect(formatBytes(1024 * 1023)).toBe('1023.0KB')
+  })
+
+  it('formats megabytes correctly', () => {
+    expect(formatBytes(1024 * 1024)).toBe('1.0MB')
+    expect(formatBytes(1024 * 1024 * 1.5)).toBe('1.5MB')
+    expect(formatBytes(1024 * 1024 * 2)).toBe('2.0MB')
+    expect(formatBytes(1024 * 1024 * 1023)).toBe('1023.0MB')
+  })
+
+  it('formats gigabytes correctly', () => {
+    expect(formatBytes(1024 * 1024 * 1024)).toBe('1.0GB')
+    expect(formatBytes(1024 * 1024 * 1024 * 1.5)).toBe('1.5GB')
+    expect(formatBytes(1024 * 1024 * 1024 * 2)).toBe('2.0GB')
+  })
+
+  it('handles very large numbers (stays at GB)', () => {
+    expect(formatBytes(1024 * 1024 * 1024 * 1024)).toBe('1024.0GB')
+    expect(formatBytes(1024 * 1024 * 1024 * 2048)).toBe('2048.0GB')
+  })
+
+  it('handles negative numbers', () => {
+    expect(formatBytes(-100)).toBe('-100B')
+    expect(formatBytes(-1024)).toBe('-1.0KB')
+    expect(formatBytes(-1024 * 1024)).toBe('-1.0MB')
+    expect(formatBytes(-1024 * 1024 * 1024)).toBe('-1.0GB')
+  })
+
+  it('handles decimal inputs', () => {
+    expect(formatBytes(100.5)).toBe('100.5B')
+    expect(formatBytes(1536.75)).toBe('1.5KB')
+  })
+
+  it('handles edge cases around unit boundaries', () => {
+    expect(formatBytes(1023.9)).toBe('1023.9B')
+    expect(formatBytes(1024.1)).toBe('1.0KB')
+    expect(formatBytes(1048575.9)).toBe('1024.0KB')
+    expect(formatBytes(1048576.1)).toBe('1.0MB')
+  })
+})

package/src/format-bytes.ts

@@ -0,0 +1,16 @@
+/**
+ * Formats a number of bytes into a human-readable string.
+ * @param bytes - The number of bytes to format.
+ * @returns A string representing the number of bytes in a human-readable format.
+ */
+export function formatBytes(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB']
+  let unitIndex = 0
+  let num = bytes
+  while (Math.abs(num) >= 1024 && unitIndex < units.length - 1) {
+    num /= 1024
+    unitIndex++
+  }
+  const fraction = unitIndex === 0 && num % 1 === 0 ? 0 : 1
+  return `${num.toFixed(fraction)}${units[unitIndex]}`
+}

package/src/get-id.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest'
+
+import { getId } from './get-id'
+
+describe('getId', () => {
+  it('returns a positive number', () => {
+    const id = getId()
+    expect(id).toBeGreaterThan(0)
+  })
+
+  it('returns different values on consecutive calls', () => {
+    expect(getId()).not.toBe(getId())
+  })
+})

package/src/get-id.ts

@@ -0,0 +1,9 @@
+let id = 0
+
+/**
+ * Generates a unique positive integer.
+ */
+export function getId(): number {
+  id = (id % Number.MAX_SAFE_INTEGER) + 1
+  return id
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './checker'
+export * from './dom'
+export { formatBytes } from './format-bytes'
+export { getId } from './get-id'
+export { once } from './once'
+export { sleep } from './sleep'

package/src/once.test.ts

@@ -0,0 +1,26 @@
+// @vitest-environment node
+
+import { describe, it, expect, vi } from 'vitest'
+
+import { once } from './once'
+
+describe('once', () => {
+  it('executes the wrapped function exactly once', () => {
+    const spy = vi.fn(() => Math.random())
+    const getRandom = once(spy)
+
+    const first = getRandom()
+    const second = getRandom()
+    const third = getRandom()
+
+    expect(spy).toHaveBeenCalledTimes(1)
+    expect(second).toBe(first)
+    expect(third).toBe(first)
+  })
+
+  it("returns the underlying function's result", () => {
+    const value = { foo: 'bar' }
+    const getValue = once(() => value)
+    expect(getValue()).toBe(value)
+  })
+})

package/src/once.ts

@@ -0,0 +1,26 @@
+/**
+ * Creates a function that will only execute the provided function once.
+ * Subsequent calls will return the cached result from the first execution.
+ *
+ * @param fn The function to execute once
+ * @returns A function that will only execute the provided function once
+ * @example
+ * ```ts
+ * const getValue = once(() => expensiveOperation())
+ * getValue() // executes expensiveOperation
+ * getValue() // returns cached result
+ * ```
+ */
+export function once<T>(fn: () => T): () => T {
+  let called = false
+  let result: T
+  return () => {
+    if (!called) {
+      result = fn()
+      called = true
+      // @ts-expect-error - micro-optimization for memory management
+      fn = undefined
+    }
+    return result
+  }
+}

package/src/sleep.test.ts

@@ -0,0 +1,44 @@
+// @vitest-environment node
+
+import { describe, it, expect, vi } from 'vitest'
+
+import { sleep } from './sleep'
+
+describe('sleep', () => {
+  it('resolves after the specified time', async () => {
+    vi.useFakeTimers()
+
+    const promise = sleep(1000)
+
+    // Advance time by 999ms - promise should not resolve yet
+    vi.advanceTimersByTime(999)
+    await Promise.resolve() // flush microtasks
+
+    let resolved = false
+    void promise.then(() => {
+      resolved = true
+    })
+    await Promise.resolve() // flush microtasks
+    expect(resolved).toBe(false)
+
+    // Advance time by 1ms more (total 1000ms) - promise should now resolve
+    vi.advanceTimersByTime(1)
+    await promise
+
+    expect(resolved).toBe(true)
+
+    vi.useRealTimers()
+  })
+
+  it('returns a promise that resolves to undefined', async () => {
+    vi.useFakeTimers()
+
+    const promise = sleep(100)
+    vi.advanceTimersByTime(100)
+
+    const result = await promise
+    expect(result).toBe(undefined)
+
+    vi.useRealTimers()
+  })
+})

package/src/sleep.ts

@@ -0,0 +1,6 @@
+/**
+ * Sleep for a given number of milliseconds.
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}