@stacksjs/utils 0.70.88 → 0.70.90

package/dist/bytes.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Format bytes to human-readable string
+ *
+ * @example
+ * ```ts
+ * formatBytes(1024) // '1 KB'
+ * formatBytes(1024, { binary: true }) // '1 KiB'
+ * formatBytes(1234567) // '1.2 MB'
+ * formatBytes(1234567, { precision: 2 }) // '1.23 MB'
+ * ```
+ */
+export declare function formatBytes(bytes: number, options?: BytesOptions): string;
+/**
+ * Parse human-readable byte string to number
+ *
+ * @example
+ * ```ts
+ * parseBytes('1 KB') // 1000
+ * parseBytes('1 KiB') // 1024
+ * parseBytes('1.5 MB') // 1500000
+ * ```
+ */
+export declare function parseBytes(input: string): number;
+/**
+ * Compare two byte values
+ */
+export declare function compareBytes(a: number | string, b: number | string): number;
+// Aliases
+export declare const prettyBytes: unknown;
+export declare const readableSize: unknown;
+/**
+ * Format bytes to human-readable string (pretty-bytes replacement)
+ */
+export declare interface BytesOptions {
+  precision?: number
+  binary?: boolean
+  space?: boolean
+  locale?: string
+  minimumFractionDigits?: number
+  maximumFractionDigits?: number
+}
+export { formatBytes as default };

package/dist/bytes.js

@@ -0,0 +1,55 @@
+const DECIMAL_UNITS = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"], BINARY_UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+export function formatBytes(bytes, options = {}) {
+  const {
+    precision = 1,
+    binary = !1,
+    space = !0,
+    locale = "en-US",
+    minimumFractionDigits = 0,
+    maximumFractionDigits = precision
+  } = options;
+  if (!Number.isFinite(bytes))
+    throw TypeError(`Expected a finite number, got ${typeof bytes}: ${bytes}`);
+  const isNegative = bytes < 0, prefix = isNegative ? "-" : "";
+  if (isNegative)
+    bytes = -bytes;
+  if (bytes < 1) {
+    const numberString = bytes.toLocaleString(locale, {
+      minimumFractionDigits,
+      maximumFractionDigits
+    });
+    return `${prefix}${numberString}${space ? " " : ""}B`;
+  }
+  const base = binary ? 1024 : 1000, units = binary ? BINARY_UNITS : DECIMAL_UNITS, exponent = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1), numberString = (bytes / base ** exponent).toLocaleString(locale, {
+    minimumFractionDigits,
+    maximumFractionDigits
+  }), unit = units[exponent];
+  return `${prefix}${numberString}${space ? " " : ""}${unit}`;
+}
+export function parseBytes(input) {
+  const match = input.match(/^(-?[\d.]+)\s*([A-Za-z]+)?$/);
+  if (!match)
+    throw Error(`Invalid byte string: ${input}`);
+  const [, numberStr, unit = "B"] = match;
+  if (numberStr === void 0)
+    throw Error(`Invalid byte string: ${input}`);
+  const number = Number.parseFloat(numberStr);
+  if (!Number.isFinite(number))
+    throw Error(`Invalid number in byte string: ${numberStr}`);
+  const normalizedUnit = unit.toUpperCase(), isBinary = normalizedUnit.endsWith("IB"), base = isBinary ? 1024 : 1000;
+  let exponent = 0;
+  const units = isBinary ? BINARY_UNITS : DECIMAL_UNITS;
+  for (let i = 0;i < units.length; i++)
+    if (units[i]?.toUpperCase() === normalizedUnit) {
+      exponent = i;
+      break;
+    }
+  return number * base ** exponent;
+}
+export function compareBytes(a, b) {
+  const bytesA = typeof a === "string" ? parseBytes(a) : a, bytesB = typeof b === "string" ? parseBytes(b) : b;
+  return bytesA - bytesB;
+}
+export const prettyBytes = formatBytes, readableSize = formatBytes;
+
+export { formatBytes as default };

package/dist/clean.d.ts

@@ -0,0 +1 @@
+export declare function cleanProject(): Promise<void>;

package/dist/clean.js

@@ -0,0 +1,13 @@
+import { path as p } from "@stacksjs/path";
+export async function cleanProject() {
+  await Bun.$`rm -rf ${p.projectPath("bun.lock")}`;
+  await Bun.$`rm -rf ${p.projectPath("yarn.lock")}`;
+  await Bun.$`rm -rf ${p.projectPath("node_modules/")}`;
+  await Bun.$`rm -rf ${p.frameworkPath("dist")}`;
+  await Bun.$`rm -rf ${p.frameworkPath("node_modules")}`;
+  await Bun.$`rm -rf ${p.frameworkPath("**/dist")}`;
+  await Bun.$`rm -rf ${p.frameworkPath("**/node_modules")}`;
+  await Bun.$`rm -rf ${p.frameworkCloudPath("cdk.out/")}`;
+  await Bun.$`rm -rf ${p.frameworkCloudPath("cdk.context.json")}`;
+  await Bun.$`rm -rf ${p.cloudPath("dist.zip")}`;
+}

package/dist/colors.d.ts

@@ -0,0 +1,146 @@
+declare function createColorFn(code: string, endCode?: string): ColorFn;
+// Strip colors from text
+export declare function stripColors(text: string): string;
+// Check if colors are supported
+export declare function supportsColor(): boolean;
+/**
+ * Terminal colors and formatting (kolorist replacement)
+ *
+ * Lightweight terminal color library with zero dependencies
+ */
+declare const isColorSupported: unknown;
+declare const colors: {
+  reset: unknown;
+  black: unknown;
+  red: unknown;
+  green: unknown;
+  yellow: unknown;
+  blue: unknown;
+  magenta: unknown;
+  cyan: unknown;
+  white: unknown;
+  gray: unknown;
+  grey: unknown;
+  lightRed: unknown;
+  lightGreen: unknown;
+  lightYellow: unknown;
+  lightBlue: unknown;
+  lightMagenta: unknown;
+  lightCyan: unknown;
+  lightGray: unknown;
+  lightGrey: unknown;
+  bgBlack: unknown;
+  bgRed: unknown;
+  bgGreen: unknown;
+  bgYellow: unknown;
+  bgBlue: unknown;
+  bgMagenta: unknown;
+  bgCyan: unknown;
+  bgWhite: unknown;
+  bgLightRed: unknown;
+  bgLightGreen: unknown;
+  bgLightYellow: unknown;
+  bgLightBlue: unknown;
+  bgLightMagenta: unknown;
+  bgLightCyan: unknown;
+  bold: unknown;
+  dim: unknown;
+  italic: unknown;
+  underline: unknown;
+  inverse: unknown;
+  hidden: unknown;
+  strikethrough: unknown
+};
+// Color functions
+export declare const black: unknown;
+export declare const red: unknown;
+export declare const green: unknown;
+export declare const yellow: unknown;
+export declare const blue: unknown;
+export declare const magenta: unknown;
+export declare const cyan: unknown;
+export declare const white: unknown;
+export declare const gray: unknown;
+export declare const grey: unknown;
+// Bright colors
+export declare const lightRed: unknown;
+export declare const lightGreen: unknown;
+export declare const lightYellow: unknown;
+export declare const lightBlue: unknown;
+export declare const lightMagenta: unknown;
+export declare const lightCyan: unknown;
+export declare const lightGray: unknown;
+export declare const lightGrey: unknown;
+// Background colors
+export declare const bgBlack: unknown;
+export declare const bgRed: unknown;
+export declare const bgGreen: unknown;
+export declare const bgYellow: unknown;
+export declare const bgBlue: unknown;
+export declare const bgMagenta: unknown;
+export declare const bgCyan: unknown;
+export declare const bgWhite: unknown;
+// Bright background colors
+export declare const bgLightRed: unknown;
+export declare const bgLightGreen: unknown;
+export declare const bgLightYellow: unknown;
+export declare const bgLightBlue: unknown;
+export declare const bgLightMagenta: unknown;
+export declare const bgLightCyan: unknown;
+// Text formatting
+export declare const bold: unknown;
+export declare const dim: unknown;
+export declare const italic: unknown;
+export declare const underline: unknown;
+export declare const inverse: unknown;
+export declare const hidden: unknown;
+export declare const strikethrough: unknown;
+// Reset
+export declare const reset: unknown;
+declare const __dtsx_default_export__: {
+  black: typeof black;
+  red: typeof red;
+  green: typeof green;
+  yellow: typeof yellow;
+  blue: typeof blue;
+  magenta: typeof magenta;
+  cyan: typeof cyan;
+  white: typeof white;
+  gray: typeof gray;
+  grey: typeof grey;
+  lightRed: typeof lightRed;
+  lightGreen: typeof lightGreen;
+  lightYellow: typeof lightYellow;
+  lightBlue: typeof lightBlue;
+  lightMagenta: typeof lightMagenta;
+  lightCyan: typeof lightCyan;
+  lightGray: typeof lightGray;
+  lightGrey: typeof lightGrey;
+  bgBlack: typeof bgBlack;
+  bgRed: typeof bgRed;
+  bgGreen: typeof bgGreen;
+  bgYellow: typeof bgYellow;
+  bgBlue: typeof bgBlue;
+  bgMagenta: typeof bgMagenta;
+  bgCyan: typeof bgCyan;
+  bgWhite: typeof bgWhite;
+  bgLightRed: typeof bgLightRed;
+  bgLightGreen: typeof bgLightGreen;
+  bgLightYellow: typeof bgLightYellow;
+  bgLightBlue: typeof bgLightBlue;
+  bgLightMagenta: typeof bgLightMagenta;
+  bgLightCyan: typeof bgLightCyan;
+  bold: typeof bold;
+  dim: typeof dim;
+  italic: typeof italic;
+  underline: typeof underline;
+  inverse: typeof inverse;
+  hidden: typeof hidden;
+  strikethrough: typeof strikethrough;
+  reset: typeof reset;
+  stripColors: typeof stripColors;
+  supportsColor: typeof supportsColor
+};
+declare type ColorFn = (_text: string | number) => string;
+// Default export
+export default __dtsx_default_export__;

package/dist/colors.js

@@ -0,0 +1,100 @@
+const isColorSupported = !process.env.NO_COLOR && (process.env.FORCE_COLOR || process.stdout?.isTTY), colors = {
+  reset: isColorSupported ? "\x1B[0m" : "",
+  black: isColorSupported ? "\x1B[30m" : "",
+  red: isColorSupported ? "\x1B[31m" : "",
+  green: isColorSupported ? "\x1B[32m" : "",
+  yellow: isColorSupported ? "\x1B[33m" : "",
+  blue: isColorSupported ? "\x1B[34m" : "",
+  magenta: isColorSupported ? "\x1B[35m" : "",
+  cyan: isColorSupported ? "\x1B[36m" : "",
+  white: isColorSupported ? "\x1B[37m" : "",
+  gray: isColorSupported ? "\x1B[90m" : "",
+  grey: isColorSupported ? "\x1B[90m" : "",
+  lightRed: isColorSupported ? "\x1B[91m" : "",
+  lightGreen: isColorSupported ? "\x1B[92m" : "",
+  lightYellow: isColorSupported ? "\x1B[93m" : "",
+  lightBlue: isColorSupported ? "\x1B[94m" : "",
+  lightMagenta: isColorSupported ? "\x1B[95m" : "",
+  lightCyan: isColorSupported ? "\x1B[96m" : "",
+  lightGray: isColorSupported ? "\x1B[37m" : "",
+  lightGrey: isColorSupported ? "\x1B[37m" : "",
+  bgBlack: isColorSupported ? "\x1B[40m" : "",
+  bgRed: isColorSupported ? "\x1B[41m" : "",
+  bgGreen: isColorSupported ? "\x1B[42m" : "",
+  bgYellow: isColorSupported ? "\x1B[43m" : "",
+  bgBlue: isColorSupported ? "\x1B[44m" : "",
+  bgMagenta: isColorSupported ? "\x1B[45m" : "",
+  bgCyan: isColorSupported ? "\x1B[46m" : "",
+  bgWhite: isColorSupported ? "\x1B[47m" : "",
+  bgLightRed: isColorSupported ? "\x1B[101m" : "",
+  bgLightGreen: isColorSupported ? "\x1B[102m" : "",
+  bgLightYellow: isColorSupported ? "\x1B[103m" : "",
+  bgLightBlue: isColorSupported ? "\x1B[104m" : "",
+  bgLightMagenta: isColorSupported ? "\x1B[105m" : "",
+  bgLightCyan: isColorSupported ? "\x1B[106m" : "",
+  bold: isColorSupported ? "\x1B[1m" : "",
+  dim: isColorSupported ? "\x1B[2m" : "",
+  italic: isColorSupported ? "\x1B[3m" : "",
+  underline: isColorSupported ? "\x1B[4m" : "",
+  inverse: isColorSupported ? "\x1B[7m" : "",
+  hidden: isColorSupported ? "\x1B[8m" : "",
+  strikethrough: isColorSupported ? "\x1B[9m" : ""
+};
+function createColorFn(code, endCode = colors.reset) {
+  return (text) => {
+    if (!isColorSupported)
+      return String(text);
+    return `${code}${text}${endCode}`;
+  };
+}
+export const black = createColorFn(colors.black), red = createColorFn(colors.red), green = createColorFn(colors.green), yellow = createColorFn(colors.yellow), blue = createColorFn(colors.blue), magenta = createColorFn(colors.magenta), cyan = createColorFn(colors.cyan), white = createColorFn(colors.white), gray = createColorFn(colors.gray), grey = gray, lightRed = createColorFn(colors.lightRed), lightGreen = createColorFn(colors.lightGreen), lightYellow = createColorFn(colors.lightYellow), lightBlue = createColorFn(colors.lightBlue), lightMagenta = createColorFn(colors.lightMagenta), lightCyan = createColorFn(colors.lightCyan), lightGray = createColorFn(colors.lightGray), lightGrey = lightGray, bgBlack = createColorFn(colors.bgBlack), bgRed = createColorFn(colors.bgRed), bgGreen = createColorFn(colors.bgGreen), bgYellow = createColorFn(colors.bgYellow), bgBlue = createColorFn(colors.bgBlue), bgMagenta = createColorFn(colors.bgMagenta), bgCyan = createColorFn(colors.bgCyan), bgWhite = createColorFn(colors.bgWhite), bgLightRed = createColorFn(colors.bgLightRed), bgLightGreen = createColorFn(colors.bgLightGreen), bgLightYellow = createColorFn(colors.bgLightYellow), bgLightBlue = createColorFn(colors.bgLightBlue), bgLightMagenta = createColorFn(colors.bgLightMagenta), bgLightCyan = createColorFn(colors.bgLightCyan), bold = createColorFn(colors.bold), dim = createColorFn(colors.dim), italic = createColorFn(colors.italic), underline = createColorFn(colors.underline), inverse = createColorFn(colors.inverse), hidden = createColorFn(colors.hidden), strikethrough = createColorFn(colors.strikethrough), reset = createColorFn(colors.reset, "");
+export function stripColors(text) {
+  return text.replace(/\x1B\[\d+m/g, "");
+}
+export function supportsColor() {
+  return !!isColorSupported;
+}
+export default {
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  grey,
+  lightRed,
+  lightGreen,
+  lightYellow,
+  lightBlue,
+  lightMagenta,
+  lightCyan,
+  lightGray,
+  lightGrey,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  bgLightRed,
+  bgLightGreen,
+  bgLightYellow,
+  bgLightBlue,
+  bgLightMagenta,
+  bgLightCyan,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  reset,
+  stripColors,
+  supportsColor
+};

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+export {
+  defineApp,
+  defineCache,
+  defineCdn,
+  defineChat,
+  defineCli,
+  defineDatabase,
+  defineDependencies,
+  defineDns,
+  defineEmail,
+  defineEmailConfig,
+  defineGit,
+  defineHashing,
+  defineLibrary,
+  defineNotification,
+  definePayment,
+  defineQueue,
+  defineSearchEngine,
+  defineServices,
+  defineSms,
+  defineFilesystems,
+  defineUi,
+} from '@stacksjs/config';

package/dist/config.js

@@ -0,0 +1,23 @@
+export {
+  defineApp,
+  defineCache,
+  defineCdn,
+  defineChat,
+  defineCli,
+  defineDatabase,
+  defineDependencies,
+  defineDns,
+  defineEmail,
+  defineEmailConfig,
+  defineGit,
+  defineHashing,
+  defineLibrary,
+  defineNotification,
+  definePayment,
+  defineQueue,
+  defineSearchEngine,
+  defineServices,
+  defineSms,
+  defineFilesystems,
+  defineUi
+} from "@stacksjs/config";

package/dist/debounce.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Creates a debounced function that delays invoking func until after wait milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ *
+ * @param fn - The function to debounce
+ * @param wait - The number of milliseconds to delay
+ * @param options - Options object
+ * @returns The debounced function
+ */
+export declare function debounce<T extends (..._args: any[]) => any>(fn: T, wait?: number, options?: DebounceOptions): T & { cancel: () => void; flush: () => void };
+/**
+ * Creates a throttled function that only invokes func at most once per every wait milliseconds
+ *
+ * @param fn - The function to throttle
+ * @param wait - The number of milliseconds to throttle
+ * @returns The throttled function
+ */
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, wait?: number): T & { cancel: () => void };
+/**
+ * Delays execution of a function
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Debounce and throttle utilities (perfect-debounce replacement)
+ */
+export declare interface DebounceOptions {
+  leading?: boolean
+  trailing?: boolean
+}

package/dist/debounce.js

@@ -0,0 +1,77 @@
+export function debounce(fn, wait = 0, options = {}) {
+  const { leading = !1, trailing = !0 } = options;
+  let timeout = null, lastArgs = null, lastThis = null, result;
+  const invokeFunc = () => {
+    if (lastArgs) {
+      result = fn.apply(lastThis, lastArgs);
+      lastArgs = null;
+      lastThis = null;
+    }
+    return result;
+  }, cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    lastArgs = null;
+    lastThis = null;
+  }, flush = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+      return invokeFunc();
+    }
+    return result;
+  }, debounced = function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    const shouldCallNow = leading && !timeout;
+    if (timeout)
+      clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (trailing && lastArgs)
+        invokeFunc();
+    }, wait);
+    if (shouldCallNow)
+      return invokeFunc();
+    return result;
+  };
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+export function throttle(fn, wait = 0) {
+  let timeout = null, lastRun = 0, lastArgs = null, lastThis = null;
+  const invokeFunc = () => {
+    if (lastArgs) {
+      fn.apply(lastThis, lastArgs);
+      lastArgs = null;
+      lastThis = null;
+      lastRun = Date.now();
+    }
+  }, cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    lastArgs = null;
+    lastThis = null;
+  }, throttled = function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    const timeSinceLastRun = Date.now() - lastRun;
+    if (timeSinceLastRun >= wait)
+      invokeFunc();
+    else if (!timeout)
+      timeout = setTimeout(() => {
+        timeout = null;
+        invokeFunc();
+      }, wait - timeSinceLastRun);
+  };
+  throttled.cancel = cancel;
+  return throttled;
+}
+export function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/detect.d.ts

@@ -0,0 +1,35 @@
+export declare function detectIndent(text: string): IndentInfo;
+/**
+ * Detect newline type in a string
+ *
+ * @returns '\r\n' (CRLF - Windows), '\n' (LF - Unix), '\r' (CR - old Mac), or null
+ */
+export declare function detectNewline(text: string): '\r\n' | '\n' | '\r' | null;
+/**
+ * Detect newline type with graceful fallback
+ */
+export declare function detectNewlineGraceful(text: string, fallback?: '\r\n' | '\n'): '\r\n' | '\n' | '\r';
+/**
+ * Normalize newlines in text to specified type
+ */
+export declare function normalizeNewlines(text: string, newline?: '\r\n' | '\n' | '\r'): string;
+/**
+ * Count different types of newlines in text
+ */
+export declare function countNewlines(text: string): {
+  crlf: number
+  lf: number
+  cr: number
+  total: number
+};
+/**
+ * Text detection utilities (detect-indent and detect-newline replacements)
+ */
+/**
+ * Detect indentation type and amount in a string
+ */
+export declare interface IndentInfo {
+  amount: number
+  type: 'space' | 'tab' | null
+  indent: string
+}

package/dist/detect.js

@@ -0,0 +1,65 @@
+export function detectIndent(text) {
+  const lines = text.split(`
+`), indents = [];
+  for (const line of lines) {
+    if (!line.trim())
+      continue;
+    const match = line.match(/^(\s+)/);
+    if (match && match[1] !== void 0)
+      indents.push(match[1]);
+  }
+  if (indents.length === 0)
+    return { amount: 0, type: null, indent: "" };
+  const indentCounts = new Map;
+  for (const indent of indents)
+    indentCounts.set(indent, (indentCounts.get(indent) || 0) + 1);
+  let mostCommon = "", maxCount = 0;
+  for (const [indent, count] of indentCounts)
+    if (count > maxCount) {
+      maxCount = count;
+      mostCommon = indent;
+    }
+  if (mostCommon.includes("\t"))
+    return {
+      amount: mostCommon.length,
+      type: "tab",
+      indent: mostCommon
+    };
+  return {
+    amount: mostCommon.length,
+    type: "space",
+    indent: mostCommon
+  };
+}
+export function detectNewline(text) {
+  if (!text)
+    return null;
+  if (text.includes(`\r
+`))
+    return `\r
+`;
+  if (text.includes(`
+`))
+    return `
+`;
+  if (text.includes("\r"))
+    return "\r";
+  return null;
+}
+export function detectNewlineGraceful(text, fallback = `
+`) {
+  return detectNewline(text) || fallback;
+}
+export function normalizeNewlines(text, newline = `
+`) {
+  return text.replace(/\r\n|\r|\n/g, newline);
+}
+export function countNewlines(text) {
+  const crlf = (text.match(/\r\n/g) || []).length, cr = (text.match(/\r(?!\n)/g) || []).length, lf = (text.match(/(?<!\r)\n/g) || []).length;
+  return {
+    crlf,
+    lf,
+    cr,
+    total: crlf + lf + cr
+  };
+}

package/dist/equal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deep equality with NaN-safety and cycle detection.
+ *
+ * - `NaN === NaN` is false in JavaScript, so the previous `Object.is`
+ *   tail correctly handled that case but only at the leaf — a
+ *   `[NaN, NaN]` pair compared element-by-element worked, but compound
+ *   structures relied on the tail. The new shape preserves that.
+ * - Circular references used to send isDeepEqual into infinite recursion
+ *   (`a.self = a; isDeepEqual(a, a)` blew the stack). A WeakSet of
+ *   already-visited objects breaks the cycle and treats two structurally
+ *   identical cycles as equal.
+ */
+export declare function isDeepEqual(value1: any, value2: any, seen?: WeakMap<object, object>): boolean;

package/dist/equal.js

@@ -0,0 +1,27 @@
+import { getTypeName } from "@stacksjs/types";
+export function isDeepEqual(value1, value2, seen = new WeakMap) {
+  if (value1 === value2)
+    return !0;
+  if (typeof value1 === "number" && typeof value2 === "number" && Number.isNaN(value1) && Number.isNaN(value2))
+    return !0;
+  const type1 = getTypeName(value1), type2 = getTypeName(value2);
+  if (type1 !== type2)
+    return !1;
+  if (value1 && typeof value1 === "object") {
+    if (seen.get(value1) === value2)
+      return !0;
+    seen.set(value1, value2);
+  }
+  if (type1 === "array") {
+    if (value1.length !== value2.length)
+      return !1;
+    return value1.every((item, i) => isDeepEqual(item, value2[i], seen));
+  }
+  if (type1 === "object") {
+    const keyArr = Object.keys(value1);
+    if (keyArr.length !== Object.keys(value2).length)
+      return !1;
+    return keyArr.every((key) => isDeepEqual(value1[key], value2[key], seen));
+  }
+  return Object.is(value1, value2);
+}