@ocavue/utils 0.8.1 → 1.0.0

package/dist/index.d.ts

@@ -3,6 +3,26 @@
  * Checks if the given value is an object.
  */
 declare function isObject(value: unknown): value is Record<string | symbol | number, unknown>;
+/**
+ * Checks if the given value is a Map.
+ */
+declare function isMap(value: unknown): value is Map<unknown, unknown>;
+/**
+ * Checks if the given value is a Set.
+ */
+declare function isSet(value: unknown): value is Set<unknown>;
+//#endregion
+//#region src/default-map.d.ts
+/**
+ * A map that automatically creates values for missing keys using a factory function.
+ *
+ * Similar to Python's [defaultdict](https://docs.python.org/3.13/library/collections.html#collections.defaultdict).
+ */
+declare class DefaultMap<K, V> extends Map<K, V> {
+  private readonly defaultFactory;
+  constructor(defaultFactory: () => V, iterable?: Iterable<readonly [K, V]>);
+  get(key: K): V;
+}
 //#endregion
 //#region src/dom.d.ts
 /**
@@ -100,5 +120,11 @@ declare function once<T>(fn: () => T): () => T;
  */
 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 };
+//#region src/is-deep-equal.d.ts
+/**
+ * Whether two values are deeply equal.
+ */
+declare function isDeepEqual(a: unknown, b: unknown): boolean;
+//#endregion
+export { DefaultMap, formatBytes, getDocument, getDocumentElement, getId, getWindow, isDeepEqual, isDocument, isDocumentFragment, isElement, isElementLike, isHTMLElement, isMap, isMathMLElement, isNodeLike, isObject, isSVGElement, isSet, isShadowRoot, isTextNode, isWindowLike, once, sleep };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/checker.ts","../src/default-map.ts","../src/dom.ts","../src/format-bytes.ts","../src/get-id.ts","../src/once.ts","../src/sleep.ts","../src/is-deep-equal.ts"],"sourcesContent":[],"mappings":";;AAGA;AASA;AAOgB,iBAhBA,QAAA,CAgBmC,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAdvC,MAcuC,CAAA,MAAA,GAAA,MAAA,GAAA,MAAA,EAAA,OAAA,CAAA;;;;ACdtC,iBDOG,KAAA,CCPO,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IDOyB,GCPzB,CAAA,OAAA,EAAA,OAAA,CAAA;;;;AAG8C,iBDWrD,KAAA,CCXqD,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IDWrB,GCXqB,CAAA,OAAA,CAAA;;;;ADLrE;AASA;AAOA;;cCda,yBAAyB,IAAI,GAAG;;EAAhC,WAAA,CAAA,cAAU,EAAA,GAAA,GAGa,CAHb,EAAA,QAAA,CAAA,EAG2B,QAH3B,CAAA,SAAA,CAG8C,CAH9C,EAGiD,CAHjD,CAAA,CAAA;EAAmB,GAAA,CAAA,GAAA,EAQtB,CARsB,CAAA,EAQlB,CARkB;;;;;ADF1C;AASA;AAOgB,iBEbA,SAAA,CFamC,IAAA,EEbnB,IFamB,CAAA,EAAA,IAAA,IEbJ,OFaI;;;;ACdtC,iBCQG,UAAA,CDRO,IAAA,ECQU,IDRV,CAAA,EAAA,IAAA,ICQyB,IDRzB;;;;AAG8C,iBCYrD,aAAA,CDZqD,IAAA,ECYjC,IDZiC,CAAA,EAAA,IAAA,ICYlB,WDZkB;;;;AAK7C,iBCcR,YAAA,CDdQ,IAAA,ECcW,IDdX,CAAA,EAAA,IAAA,ICc0B,UDd1B;;;;iBCqBR,eAAA,OAAsB,eAAe;;AA5BrD;AAOA;AAOgB,iBAwBA,UAAA,CAxBoB,IAAe,EAwBlB,IAxBkB,CAAA,EAAA,IAAW,IAwBd,QAxBc;AAO9D;AAOA;AAUA;AAOgB,iBAAA,kBAAA,CAAwC,IAAA,EAAf,IAAe,CAAA,EAAA,IAAgB,IAAhB,gBAAgB;AAOxE;AAOA;AAOA;AAWgB,iBAzBA,YAAA,CAyBuC,IAAM,EAzB1B,IAyB0B,CAAA,EAAA,IAAA,IAzBX,UAyBW;AAQ7D;;;AAC+B,iBA3Bf,UAAA,CA2Be,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IA3BsB,IA2BtB;;;;AAoBf,iBAxCA,aAAA,CAwCW,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAxC6B,OAwC7B;;;;AACU,iBA9BrB,YAAA,CA8BqB,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IA9BkB,MA8BlB;;;AAiBrC;;AACqB,iBAxCL,SAAA,CAwCK,MAAA,CAAA,EAvCV,IAuCU,GAvCH,UAuCG,GAvCU,QAuCV,GAAA,IAAA,CAAA,EAtClB,MAsCkB,GAAA,OAtCF,UAsCE;;;;;iBAnBL,WAAA,UACL,UAAU,SAAS,OAAO,kBAClC;;;AC7GH;iBD6HgB,kBAAA,UACL,UAAU,OAAO,SAAS,kBAClC;;;;AFjIH;AASA;AAOA;;iBGdgB,WAAA;;;;AHFhB;AASA;AAOgB,iBIdA,KAAA,CAAA,CJcmC,EAAA,MAAA;;;;AAhBnD;AASA;AAOA;;;;ACdA;;;;;;AAGkD,iBIKlC,IJLkC,CAAA,CAAA,CAAA,CAAA,EAAA,EAAA,GAAA,GIKhB,CJLgB,CAAA,EAAA,GAAA,GIKN,CJLM;;;;ADLlD;AASA;AAOgB,iBMhBA,KAAA,CNgBmC,EAAA,EAAA,MAAA,CAAA,EMhBhB,ONgBgB,CAAA,IAAA,CAAA;;;;AAhBnD;AASA;AAOgB,iBOdA,WAAA,CPcmC,CAAA,EAAA,OAAA,EAAA,CAAA,EAAA,OAAA,CAAA,EAAA,OAAA"}

package/dist/index.js

@@ -5,6 +5,38 @@
 function isObject(value) {
 	return value != null && typeof value === "object";
 }
+/**
+* Checks if the given value is a Map.
+*/
+function isMap(value) {
+	return value instanceof Map;
+}
+/**
+* Checks if the given value is a Set.
+*/
+function isSet(value) {
+	return value instanceof Set;
+}
+
+//#endregion
+//#region src/default-map.ts
+/**
+* A map that automatically creates values for missing keys using a factory function.
+*
+* Similar to Python's [defaultdict](https://docs.python.org/3.13/library/collections.html#collections.defaultdict).
+*/
+var DefaultMap = class extends Map {
+	constructor(defaultFactory, iterable) {
+		super(iterable);
+		this.defaultFactory = defaultFactory;
+	}
+	get(key) {
+		if (this.has(key)) return super.get(key);
+		const value = this.defaultFactory();
+		this.set(key, value);
+		return value;
+	}
+};
 
 //#endregion
 //#region src/dom-node-type.ts
@@ -185,5 +217,48 @@ function sleep(ms) {
 }
 
 //#endregion
-export { formatBytes, getDocument, getDocumentElement, getId, getWindow, isDocument, isDocumentFragment, isElement, isElementLike, isHTMLElement, isMathMLElement, isNodeLike, isObject, isSVGElement, isShadowRoot, isTextNode, isWindowLike, once, sleep };
+//#region src/is-deep-equal.ts
+/**
+* Whether two values are deeply equal.
+*/
+function isDeepEqual(a, b) {
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+	const aType = typeof a;
+	if (aType !== typeof b) return false;
+	if (aType === "number" && Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b)) return false;
+		if (a.length !== b.length) return false;
+		const size = a.length;
+		for (let i = 0; i < size; i++) if (!isDeepEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (isSet(a)) {
+		if (!isSet(b)) return false;
+		if (a.size !== b.size) return false;
+		for (const value of a) if (!b.has(value)) return false;
+		return true;
+	}
+	if (isMap(a)) {
+		if (!isMap(b)) return false;
+		if (a.size !== b.size) return false;
+		for (const key of a.keys()) {
+			if (!b.has(key)) return false;
+			if (!isDeepEqual(a.get(key), b.get(key))) return false;
+		}
+		return true;
+	}
+	if (typeof a === "object" && typeof b === "object") {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys.length !== bKeys.length) return false;
+		for (const key of aKeys) if (!isDeepEqual(a[key], b[key])) return false;
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { DefaultMap, formatBytes, getDocument, getDocumentElement, getId, getWindow, isDeepEqual, isDocument, isDocumentFragment, isElement, isElementLike, isHTMLElement, isMap, isMathMLElement, isNodeLike, isObject, isSVGElement, isSet, isShadowRoot, isTextNode, isWindowLike, once, sleep };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +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"}
+{"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/default-map.ts","../src/dom-node-type.ts","../src/dom.ts","../src/format-bytes.ts","../src/get-id.ts","../src/once.ts","../src/sleep.ts","../src/is-deep-equal.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\n/**\n * Checks if the given value is a Map.\n */\nexport function isMap(value: unknown): value is Map<unknown, unknown> {\n  return value instanceof Map\n}\n\n/**\n * Checks if the given value is a Set.\n */\nexport function isSet(value: unknown): value is Set<unknown> {\n  return value instanceof Set\n}\n","/**\n * A map that automatically creates values for missing keys using a factory function.\n *\n * Similar to Python's [defaultdict](https://docs.python.org/3.13/library/collections.html#collections.defaultdict).\n */\nexport class DefaultMap<K, V> extends Map<K, V> {\n  private readonly defaultFactory: () => V\n\n  constructor(defaultFactory: () => V, iterable?: Iterable<readonly [K, V]>) {\n    super(iterable)\n    this.defaultFactory = defaultFactory\n  }\n\n  override get(key: K): V {\n    if (this.has(key)) {\n      return super.get(key)!\n    }\n    const value = this.defaultFactory()\n    this.set(key, value)\n    return value\n  }\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","import { isMap, isSet } from './checker'\n\n/**\n * Whether two values are deeply equal.\n */\nexport function isDeepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) {\n    return true\n  }\n\n  // Handle null and undefined early\n  if (a == null || b == null) {\n    return false\n  }\n\n  const aType = typeof a\n  const bType = typeof b\n  if (aType !== bType) {\n    return false\n  }\n\n  if (aType === 'number' && Number.isNaN(a) && Number.isNaN(b)) {\n    return true\n  }\n\n  if (Array.isArray(a)) {\n    if (!Array.isArray(b)) {\n      return false\n    }\n    if (a.length !== b.length) {\n      return false\n    }\n    const size = a.length\n    for (let i = 0; i < size; i++) {\n      if (!isDeepEqual(a[i], b[i])) {\n        return false\n      }\n    }\n    return true\n  }\n\n  if (isSet(a)) {\n    if (!isSet(b)) {\n      return false\n    }\n    if (a.size !== b.size) {\n      return false\n    }\n    for (const value of a) {\n      if (!b.has(value)) {\n        return false\n      }\n    }\n    return true\n  }\n\n  if (isMap(a)) {\n    if (!isMap(b)) {\n      return false\n    }\n    if (a.size !== b.size) {\n      return false\n    }\n    for (const key of a.keys()) {\n      if (!b.has(key)) {\n        return false\n      }\n      if (!isDeepEqual(a.get(key), b.get(key))) {\n        return false\n      }\n    }\n    return true\n  }\n\n  if (typeof a === 'object' && typeof b === 'object') {\n    const aKeys = Object.keys(a)\n    const bKeys = Object.keys(b)\n    if (aKeys.length !== bKeys.length) {\n      return false\n    }\n    for (const key of aKeys) {\n      if (\n        !isDeepEqual(\n          (a as Record<string, unknown>)[key],\n          (b as Record<string, unknown>)[key],\n        )\n      ) {\n        return false\n      }\n    }\n    return true\n  }\n\n  return false\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocavue/utils",
   "type": "module",
-  "version": "0.8.1",
+  "version": "1.0.0",
   "description": "A collection of utility functions for the browser and other environments",
   "author": "ocavue <ocavue@gmail.com>",
   "license": "MIT",
@@ -37,19 +37,20 @@
     "dist"
   ],
   "devDependencies": {
-    "@ocavue/eslint-config": "^3.6.1",
-    "@ocavue/tsconfig": "^0.5.0",
+    "@ocavue/eslint-config": "^3.6.2",
+    "@ocavue/tsconfig": "^0.6.1",
     "@size-limit/preset-small-lib": "^11.2.0",
     "@types/node": "^24.9.2",
-    "@vitest/coverage-v8": "4.0.4",
+    "@vitest/coverage-v8": "4.0.13",
     "eslint": "^9.38.0",
-    "jsdom": "^27.0.1",
+    "jsdom": "^27.2.0",
+    "pkg-pr-new": "^0.0.60",
     "prettier": "^3.6.2",
     "size-limit": "^11.2.0",
-    "tsdown": "^0.15.11",
+    "tsdown": "^0.16.6",
     "typescript": "^5.9.3",
-    "vite": "^7.1.12",
-    "vitest": "^4.0.4"
+    "vite": "^7.2.4",
+    "vitest": "^4.0.13"
   },
   "publishConfig": {
     "access": "public"
@@ -69,6 +70,7 @@
     "dev": "tsdown --watch",
     "lint": "eslint .",
     "fix": "eslint --fix . && prettier --write .",
+    "ci:publish:snapshot": "pkg-pr-new publish --pnpm",
     "test": "vitest",
     "typecheck": "tsc -b"
   }

package/src/checker.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, expect, it } from 'vitest'
 
-import { isObject } from './checker'
+import { isMap, isObject, isSet } from './checker'
 
 describe('isObject', () => {
   it('returns true for plain objects', () => {
@@ -38,3 +38,37 @@ describe('isObject', () => {
     expect(isObject(new TestClass())).toBe(true)
   })
 })
+
+describe('isMap', () => {
+  it('returns true for Map instances', () => {
+    expect(isMap(new Map())).toBe(true)
+    expect(isMap(new Map([['key', 'value']]))).toBe(true)
+  })
+
+  it('returns false for non-Map values', () => {
+    expect(isMap({})).toBe(false)
+    expect(isMap([])).toBe(false)
+    expect(isMap(new Set())).toBe(false)
+    expect(isMap(null)).toBe(false)
+    expect(isMap(undefined)).toBe(false)
+    expect(isMap('map')).toBe(false)
+    expect(isMap(42)).toBe(false)
+  })
+})
+
+describe('isSet', () => {
+  it('returns true for Set instances', () => {
+    expect(isSet(new Set())).toBe(true)
+    expect(isSet(new Set([1, 2, 3]))).toBe(true)
+  })
+
+  it('returns false for non-Set values', () => {
+    expect(isSet({})).toBe(false)
+    expect(isSet([])).toBe(false)
+    expect(isSet(new Map())).toBe(false)
+    expect(isSet(null)).toBe(false)
+    expect(isSet(undefined)).toBe(false)
+    expect(isSet('set')).toBe(false)
+    expect(isSet(42)).toBe(false)
+  })
+})

package/src/checker.ts

@@ -6,3 +6,17 @@ export function isObject(
 ): value is Record<string | symbol | number, unknown> {
   return value != null && typeof value === 'object'
 }
+
+/**
+ * Checks if the given value is a Map.
+ */
+export function isMap(value: unknown): value is Map<unknown, unknown> {
+  return value instanceof Map
+}
+
+/**
+ * Checks if the given value is a Set.
+ */
+export function isSet(value: unknown): value is Set<unknown> {
+  return value instanceof Set
+}

package/src/default-map.test.ts

@@ -0,0 +1,183 @@
+// @vitest-environment node
+
+import { describe, it, expect } from 'vitest'
+
+import { DefaultMap } from './default-map'
+
+describe('DefaultMap', () => {
+  it('creates default values for missing keys', () => {
+    const map = new DefaultMap<string, number>(() => 0)
+
+    expect(map.get('key1')).toBe(0)
+    expect(map.get('key2')).toBe(0)
+  })
+
+  it('returns existing values for set keys', () => {
+    const map = new DefaultMap<string, number>(() => 0)
+
+    map.set('key1', 42)
+    expect(map.get('key1')).toBe(42)
+  })
+
+  it('stores the default value when accessing missing key', () => {
+    const map = new DefaultMap<string, number>(() => 5)
+
+    const value = map.get('key1')
+    expect(value).toBe(5)
+    expect(map.has('key1')).toBe(true)
+    expect(map.get('key1')).toBe(5)
+  })
+
+  it('works with array factory', () => {
+    const map = new DefaultMap<string, string[]>(() => [])
+
+    map.get('key1').push('item1')
+    map.get('key1').push('item2')
+    map.get('key2').push('item3')
+
+    expect(map.get('key1')).toEqual(['item1', 'item2'])
+    expect(map.get('key2')).toEqual(['item3'])
+  })
+
+  it('works with object factory', () => {
+    const map = new DefaultMap<string, { count: number }>(() => ({
+      count: 0,
+    }))
+
+    map.get('key1').count += 1
+    map.get('key1').count += 1
+    map.get('key2').count += 5
+
+    expect(map.get('key1').count).toBe(2)
+    expect(map.get('key2').count).toBe(5)
+  })
+
+  it('accepts initial entries via array', () => {
+    const initialEntries: [string, number][] = [
+      ['a', 1],
+      ['b', 2],
+      ['c', 3],
+    ]
+    const map = new DefaultMap<string, number>(() => 0, initialEntries)
+
+    expect(map.get('a')).toBe(1)
+    expect(map.get('b')).toBe(2)
+    expect(map.get('c')).toBe(3)
+    expect(map.get('d')).toBe(0)
+  })
+
+  it('accepts initial entries via non-array iterable', () => {
+    const existingMap = new Map<string, number>([
+      ['x', 10],
+      ['y', 20],
+      ['z', 30],
+    ])
+    const map = new DefaultMap<string, number>(() => 0, existingMap)
+
+    expect(map.get('x')).toBe(10)
+    expect(map.get('y')).toBe(20)
+    expect(map.get('z')).toBe(30)
+    expect(map.get('w')).toBe(0)
+  })
+
+  it('calls factory function only when key is missing', () => {
+    let callCount = 0
+    const map = new DefaultMap<string, number>(() => {
+      callCount++
+      return 42
+    })
+
+    map.set('existing', 100)
+
+    map.get('existing')
+    expect(callCount).toBe(0)
+
+    map.get('new')
+    expect(callCount).toBe(1)
+
+    map.get('new')
+    expect(callCount).toBe(1)
+
+    map.get('another')
+    expect(callCount).toBe(2)
+  })
+
+  it('works with size property', () => {
+    const map = new DefaultMap<string, number>(() => 0)
+
+    expect(map.size).toBe(0)
+
+    map.get('key1')
+    expect(map.size).toBe(1)
+
+    map.get('key2')
+    expect(map.size).toBe(2)
+
+    map.get('key1')
+    expect(map.size).toBe(2)
+  })
+
+  it('works with delete method', () => {
+    const map = new DefaultMap<string, number>(() => 10)
+
+    map.get('key1')
+    expect(map.has('key1')).toBe(true)
+
+    map.delete('key1')
+    expect(map.has('key1')).toBe(false)
+
+    const value = map.get('key1')
+    expect(value).toBe(10)
+    expect(map.has('key1')).toBe(true)
+  })
+
+  it('works with clear method', () => {
+    const map = new DefaultMap<string, number>(() => 0)
+
+    map.get('key1')
+    map.get('key2')
+    expect(map.size).toBe(2)
+
+    map.clear()
+    expect(map.size).toBe(0)
+    expect(map.has('key1')).toBe(false)
+  })
+
+  it('works with iteration methods', () => {
+    const map = new DefaultMap<string, number>(() => 0, [
+      ['a', 1],
+      ['b', 2],
+    ])
+
+    expect([...map.keys()]).toEqual(['a', 'b'])
+    expect([...map.values()]).toEqual([1, 2])
+    expect([...map.entries()]).toEqual([
+      ['a', 1],
+      ['b', 2],
+    ])
+  })
+
+  it('creates independent default values', () => {
+    const map = new DefaultMap<string, number[]>(() => [])
+
+    map.get('key1').push(1)
+    map.get('key2').push(2)
+
+    expect(map.get('key1')).toEqual([1])
+    expect(map.get('key2')).toEqual([2])
+  })
+
+  it('works with nested DefaultMaps', () => {
+    const map = new DefaultMap<string, DefaultMap<string, number>>(
+      () => new DefaultMap<string, number>(() => 0),
+    )
+
+    map.get('group1').get('item1')
+    map.get('group1').set('item2', 5)
+    map.get('group2').get('item1')
+
+    expect(map.get('group1').get('item1')).toBe(0)
+    expect(map.get('group1').get('item2')).toBe(5)
+    expect(map.get('group2').get('item1')).toBe(0)
+  })
+})

package/src/default-map.ts

@@ -0,0 +1,22 @@
+/**
+ * A map that automatically creates values for missing keys using a factory function.
+ *
+ * Similar to Python's [defaultdict](https://docs.python.org/3.13/library/collections.html#collections.defaultdict).
+ */
+export class DefaultMap<K, V> extends Map<K, V> {
+  private readonly defaultFactory: () => V
+
+  constructor(defaultFactory: () => V, iterable?: Iterable<readonly [K, V]>) {
+    super(iterable)
+    this.defaultFactory = defaultFactory
+  }
+
+  override get(key: K): V {
+    if (this.has(key)) {
+      return super.get(key)!
+    }
+    const value = this.defaultFactory()
+    this.set(key, value)
+    return value
+  }
+}

package/src/index.ts

@@ -1,6 +1,8 @@
 export * from './checker'
+export { DefaultMap } from './default-map'
 export * from './dom'
 export { formatBytes } from './format-bytes'
 export { getId } from './get-id'
 export { once } from './once'
 export { sleep } from './sleep'
+export { isDeepEqual } from './is-deep-equal'

package/src/is-deep-equal.test.ts

@@ -0,0 +1,219 @@
+// @vitest-environment node
+
+import { describe, expect, it } from 'vitest'
+
+import { isDeepEqual } from './is-deep-equal'
+
+describe('isDeepEqual', () => {
+  describe('primitives', () => {
+    it('returns true for identical primitives', () => {
+      expect(isDeepEqual(42, 42)).toBe(true)
+      expect(isDeepEqual('hello', 'hello')).toBe(true)
+      expect(isDeepEqual(true, true)).toBe(true)
+      expect(isDeepEqual(false, false)).toBe(true)
+      expect(isDeepEqual(null, null)).toBe(true)
+      expect(isDeepEqual(undefined, undefined)).toBe(true)
+    })
+
+    it('returns false for different primitives', () => {
+      expect(isDeepEqual(42, 43)).toBe(false)
+      expect(isDeepEqual('hello', 'world')).toBe(false)
+      expect(isDeepEqual(true, false)).toBe(false)
+    })
+
+    it('returns false for different types', () => {
+      expect(isDeepEqual(42, '42')).toBe(false)
+      expect(isDeepEqual(0, false)).toBe(false)
+      expect(isDeepEqual('', false)).toBe(false)
+      expect(isDeepEqual(null, undefined)).toBe(false)
+    })
+
+    it('handles NaN correctly', () => {
+      expect(isDeepEqual(Number.NaN, Number.NaN)).toBe(true)
+      expect(isDeepEqual(Number.NaN, 0)).toBe(false)
+    })
+
+    it('returns false when comparing null or undefined with other values', () => {
+      expect(isDeepEqual(null, 0)).toBe(false)
+      expect(isDeepEqual(undefined, 0)).toBe(false)
+      expect(isDeepEqual(null, '')).toBe(false)
+      expect(isDeepEqual(undefined, '')).toBe(false)
+    })
+  })
+
+  describe('arrays', () => {
+    it('returns true for identical arrays', () => {
+      expect(isDeepEqual([], [])).toBe(true)
+      expect(isDeepEqual([1, 2, 3], [1, 2, 3])).toBe(true)
+      expect(isDeepEqual(['a', 'b'], ['a', 'b'])).toBe(true)
+    })
+
+    it('returns false for arrays with different lengths', () => {
+      expect(isDeepEqual([1, 2], [1, 2, 3])).toBe(false)
+      expect(isDeepEqual([1], [])).toBe(false)
+    })
+
+    it('returns false for arrays with different values', () => {
+      expect(isDeepEqual([1, 2, 3], [1, 2, 4])).toBe(false)
+      expect(isDeepEqual(['a', 'b'], ['a', 'c'])).toBe(false)
+    })
+
+    it('handles nested arrays', () => {
+      expect(isDeepEqual([[1, 2], [3, 4]], [[1, 2], [3, 4]])).toBe(true)
+      expect(isDeepEqual([[1, 2], [3, 4]], [[1, 2], [3, 5]])).toBe(false)
+    })
+  })
+
+  describe('objects', () => {
+    it('returns true for identical objects', () => {
+      expect(isDeepEqual({}, {})).toBe(true)
+      expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
+    })
+
+    it('returns false for objects with different keys', () => {
+      expect(isDeepEqual({ a: 1 }, { b: 1 })).toBe(false)
+      expect(isDeepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false)
+    })
+
+    it('returns false for objects with different values', () => {
+      expect(isDeepEqual({ a: 1 }, { a: 2 })).toBe(false)
+      expect(isDeepEqual({ a: 'hello' }, { a: 'world' })).toBe(false)
+    })
+
+    it('handles nested objects', () => {
+      expect(isDeepEqual({ a: { b: 1 } }, { a: { b: 1 } })).toBe(true)
+      expect(isDeepEqual({ a: { b: 1 } }, { a: { b: 2 } })).toBe(false)
+    })
+
+    it('handles objects with arrays', () => {
+      expect(isDeepEqual({ arr: [1, 2, 3] }, { arr: [1, 2, 3] })).toBe(true)
+      expect(isDeepEqual({ arr: [1, 2, 3] }, { arr: [1, 2, 4] })).toBe(false)
+    })
+  })
+
+  describe('Sets', () => {
+    it('returns true for identical sets', () => {
+      expect(isDeepEqual(new Set(), new Set())).toBe(true)
+      expect(isDeepEqual(new Set([1, 2, 3]), new Set([1, 2, 3]))).toBe(true)
+      expect(isDeepEqual(new Set(['a', 'b']), new Set(['a', 'b']))).toBe(true)
+    })
+
+    it('returns false for sets with different sizes', () => {
+      expect(isDeepEqual(new Set([1, 2]), new Set([1, 2, 3]))).toBe(false)
+      expect(isDeepEqual(new Set([1]), new Set())).toBe(false)
+    })
+
+    it('returns false for sets with different values', () => {
+      expect(isDeepEqual(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false)
+      expect(isDeepEqual(new Set(['a', 'b']), new Set(['a', 'c']))).toBe(
+        false,
+      )
+    })
+
+    it('handles set order independence', () => {
+      expect(isDeepEqual(new Set([1, 2, 3]), new Set([3, 2, 1]))).toBe(true)
+    })
+  })
+
+  describe('Maps', () => {
+    it('returns true for identical maps', () => {
+      expect(isDeepEqual(new Map(), new Map())).toBe(true)
+      expect(
+        isDeepEqual(
+          new Map([
+            ['a', 1],
+            ['b', 2],
+          ]),
+          new Map([
+            ['a', 1],
+            ['b', 2],
+          ]),
+        ),
+      ).toBe(true)
+    })
+
+    it('returns false for maps with different sizes', () => {
+      expect(
+        isDeepEqual(
+          new Map([['a', 1]]),
+          new Map([
+            ['a', 1],
+            ['b', 2],
+          ]),
+        ),
+      ).toBe(false)
+    })
+
+    it('returns false for maps with different keys', () => {
+      expect(
+        isDeepEqual(new Map([['a', 1]]), new Map([['b', 1]])),
+      ).toBe(false)
+    })
+
+    it('returns false for maps with different values', () => {
+      expect(
+        isDeepEqual(new Map([['a', 1]]), new Map([['a', 2]])),
+      ).toBe(false)
+    })
+
+    it('handles nested values in maps', () => {
+      expect(
+        isDeepEqual(
+          new Map([['a', { b: 1 }]]),
+          new Map([['a', { b: 1 }]]),
+        ),
+      ).toBe(true)
+      expect(
+        isDeepEqual(
+          new Map([['a', { b: 1 }]]),
+          new Map([['a', { b: 2 }]]),
+        ),
+      ).toBe(false)
+    })
+
+    it('handles arrays as map values', () => {
+      expect(
+        isDeepEqual(
+          new Map([['a', [1, 2, 3]]]),
+          new Map([['a', [1, 2, 3]]]),
+        ),
+      ).toBe(true)
+      expect(
+        isDeepEqual(
+          new Map([['a', [1, 2, 3]]]),
+          new Map([['a', [1, 2, 4]]]),
+        ),
+      ).toBe(false)
+    })
+  })
+
+  describe('mixed types', () => {
+    it('returns false when comparing different collection types', () => {
+      expect(isDeepEqual([], {})).toBe(false)
+      expect(isDeepEqual(new Set(), new Map())).toBe(false)
+      expect(isDeepEqual(new Set([1, 2]), [1, 2])).toBe(false)
+      expect(isDeepEqual(new Map(), {})).toBe(false)
+    })
+
+    it('handles complex nested structures', () => {
+      const obj1 = {
+        arr: [1, 2, { nested: true }],
+        map: new Map([['key', [1, 2, 3]]]),
+        set: new Set([1, 2, 3]),
+      }
+      const obj2 = {
+        arr: [1, 2, { nested: true }],
+        map: new Map([['key', [1, 2, 3]]]),
+        set: new Set([1, 2, 3]),
+      }
+      const obj3 = {
+        arr: [1, 2, { nested: false }],
+        map: new Map([['key', [1, 2, 3]]]),
+        set: new Set([1, 2, 3]),
+      }
+
+      expect(isDeepEqual(obj1, obj2)).toBe(true)
+      expect(isDeepEqual(obj1, obj3)).toBe(false)
+    })
+  })
+})

package/src/is-deep-equal.ts

@@ -0,0 +1,95 @@
+import { isMap, isSet } from './checker'
+
+/**
+ * Whether two values are deeply equal.
+ */
+export function isDeepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) {
+    return true
+  }
+
+  // Handle null and undefined early
+  if (a == null || b == null) {
+    return false
+  }
+
+  const aType = typeof a
+  const bType = typeof b
+  if (aType !== bType) {
+    return false
+  }
+
+  if (aType === 'number' && Number.isNaN(a) && Number.isNaN(b)) {
+    return true
+  }
+
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false
+    }
+    if (a.length !== b.length) {
+      return false
+    }
+    const size = a.length
+    for (let i = 0; i < size; i++) {
+      if (!isDeepEqual(a[i], b[i])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  if (isSet(a)) {
+    if (!isSet(b)) {
+      return false
+    }
+    if (a.size !== b.size) {
+      return false
+    }
+    for (const value of a) {
+      if (!b.has(value)) {
+        return false
+      }
+    }
+    return true
+  }
+
+  if (isMap(a)) {
+    if (!isMap(b)) {
+      return false
+    }
+    if (a.size !== b.size) {
+      return false
+    }
+    for (const key of a.keys()) {
+      if (!b.has(key)) {
+        return false
+      }
+      if (!isDeepEqual(a.get(key), b.get(key))) {
+        return false
+      }
+    }
+    return true
+  }
+
+  if (typeof a === 'object' && typeof b === 'object') {
+    const aKeys = Object.keys(a)
+    const bKeys = Object.keys(b)
+    if (aKeys.length !== bKeys.length) {
+      return false
+    }
+    for (const key of aKeys) {
+      if (
+        !isDeepEqual(
+          (a as Record<string, unknown>)[key],
+          (b as Record<string, unknown>)[key],
+        )
+      ) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return false
+}