@vef-framework/shared 1.0.135 → 2.0.1

package/dist/cjs/index.cjs

@@ -0,0 +1,339 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('./color/index.cjs');
+require('./constants/index.cjs');
+require('./types/index.cjs');
+require('./utils/index.cjs');
+const colorOps = require('./color/color-ops.cjs');
+const name = require('./color/name.cjs');
+const palette = require('./color/palette.cjs');
+const colorNames = require('./constants/color-names.cjs');
+const colorPalettes = require('./constants/color-palettes.cjs');
+const chrono = require('./utils/chrono.cjs');
+const equal = require('./utils/equal.cjs');
+const error = require('./utils/error.cjs');
+const event = require('./utils/event.cjs');
+const format = require('./utils/format.cjs');
+const _function = require('./utils/function.cjs');
+const id = require('./utils/id.cjs');
+const key = require('./utils/key.cjs');
+const klona = require('klona');
+const qs = require('qs');
+const radashi = require('radashi');
+const lib = require('./utils/lib.cjs');
+const object = require('./utils/object.cjs');
+const path = require('./utils/path.cjs');
+const pinyin = require('./utils/pinyin.cjs');
+const security = require('./utils/security.cjs');
+const string = require('./utils/string.cjs');
+const task = require('./utils/task.cjs');
+const tree = require('./utils/tree.cjs');
+const zod = require('zod');
+
+
+
+exports.convertHslToHex = colorOps.convertHslToHex;
+exports.convertTransparentToOpaque = colorOps.convertTransparentToOpaque;
+exports.getColorDifference = colorOps.getColorDifference;
+exports.isValidColor = colorOps.isValidColor;
+exports.isWhiteColor = colorOps.isWhiteColor;
+exports.mixColor = colorOps.mixColor;
+exports.setColorAlpha = colorOps.setColorAlpha;
+exports.toHexColor = colorOps.toHexColor;
+exports.toHslColor = colorOps.toHslColor;
+exports.toHsvColor = colorOps.toHsvColor;
+exports.toRgbColor = colorOps.toRgbColor;
+exports.getColorName = name.getColorName;
+exports.getColorPalette = palette.getColorPalette;
+exports.colorEntries = colorNames.colorEntries;
+exports.colorNameMap = colorNames.colorNameMap;
+exports.colorPaletteMap = colorPalettes.colorPaletteMap;
+exports.colorPalettes = colorPalettes.colorPalettes;
+exports.DEFAULT_DATETIME_FORMAT = chrono.DEFAULT_DATETIME_FORMAT;
+exports.DEFAULT_DATE_FORMAT = chrono.DEFAULT_DATE_FORMAT;
+exports.DEFAULT_TIME_FORMAT = chrono.DEFAULT_TIME_FORMAT;
+exports.LOCALIZED_DATETIME_FORMAT = chrono.LOCALIZED_DATETIME_FORMAT;
+exports.LOCALIZED_DATE_FORMAT = chrono.LOCALIZED_DATE_FORMAT;
+exports.formatDate = chrono.formatDate;
+exports.formatDuration = chrono.formatDuration;
+exports.getLocalizedDateTime = chrono.getLocalizedDateTime;
+exports.getNow = chrono.getNow;
+exports.getNowDateString = chrono.getNowDateString;
+exports.getNowDateTimeString = chrono.getNowDateTimeString;
+exports.getNowTimeString = chrono.getNowTimeString;
+exports.getTemporalFormats = chrono.getTemporalFormats;
+exports.parseDate = chrono.parseDate;
+exports.tryParseDate = chrono.tryParseDate;
+exports.isDeepEqual = equal.isDeepEqual;
+exports.isShallowEqual = equal.isShallowEqual;
+exports.filterUserFrame = error.filterUserFrame;
+exports.getCurrentStack = error.getCurrentStack;
+exports.getCurrentStackSync = error.getCurrentStackSync;
+exports.getSanitizedErrorStack = error.getSanitizedErrorStack;
+exports.parseErrorStack = error.parseErrorStack;
+exports.EventEmitter = event.EventEmitter;
+exports.createEventEmitter = event.createEventEmitter;
+exports.formatBytes = format.formatBytes;
+exports.formatNumber = format.formatNumber;
+exports.createThrowNotImplementedFn = _function.createThrowNotImplementedFn;
+exports.identity = _function.identity;
+exports.invokeAwaitableFn = _function.invokeAwaitableFn;
+exports.isAsyncFunction = _function.isAsyncFunction;
+exports.throwNotImplemented = _function.throwNotImplemented;
+exports.generateId = id.generateId;
+exports.hashKey = key.hashKey;
+Object.defineProperty(exports, "cloneDeep", {
+	enumerable: true,
+	get: () => klona.klona
+});
+Object.defineProperty(exports, "decodeQueryString", {
+	enumerable: true,
+	get: () => qs.parse
+});
+Object.defineProperty(exports, "encodeQueryString", {
+	enumerable: true,
+	get: () => qs.stringify
+});
+Object.defineProperty(exports, "always", {
+	enumerable: true,
+	get: () => radashi.always
+});
+Object.defineProperty(exports, "assign", {
+	enumerable: true,
+	get: () => radashi.assign
+});
+Object.defineProperty(exports, "camelCase", {
+	enumerable: true,
+	get: () => radashi.camel
+});
+Object.defineProperty(exports, "capitalize", {
+	enumerable: true,
+	get: () => radashi.capitalize
+});
+Object.defineProperty(exports, "cluster", {
+	enumerable: true,
+	get: () => radashi.cluster
+});
+Object.defineProperty(exports, "debounce", {
+	enumerable: true,
+	get: () => radashi.debounce
+});
+Object.defineProperty(exports, "first", {
+	enumerable: true,
+	get: () => radashi.first
+});
+Object.defineProperty(exports, "get", {
+	enumerable: true,
+	get: () => radashi.get
+});
+Object.defineProperty(exports, "isArray", {
+	enumerable: true,
+	get: () => radashi.isArray
+});
+Object.defineProperty(exports, "isBigInt", {
+	enumerable: true,
+	get: () => radashi.isBigInt
+});
+Object.defineProperty(exports, "isBoolean", {
+	enumerable: true,
+	get: () => radashi.isBoolean
+});
+Object.defineProperty(exports, "isDate", {
+	enumerable: true,
+	get: () => radashi.isDate
+});
+Object.defineProperty(exports, "isEmpty", {
+	enumerable: true,
+	get: () => radashi.isEmpty
+});
+Object.defineProperty(exports, "isError", {
+	enumerable: true,
+	get: () => radashi.isError
+});
+Object.defineProperty(exports, "isFloat", {
+	enumerable: true,
+	get: () => radashi.isFloat
+});
+Object.defineProperty(exports, "isFunction", {
+	enumerable: true,
+	get: () => radashi.isFunction
+});
+Object.defineProperty(exports, "isInt", {
+	enumerable: true,
+	get: () => radashi.isInt
+});
+Object.defineProperty(exports, "isIntString", {
+	enumerable: true,
+	get: () => radashi.isIntString
+});
+Object.defineProperty(exports, "isMap", {
+	enumerable: true,
+	get: () => radashi.isMap
+});
+Object.defineProperty(exports, "isNullish", {
+	enumerable: true,
+	get: () => radashi.isNullish
+});
+Object.defineProperty(exports, "isNumber", {
+	enumerable: true,
+	get: () => radashi.isNumber
+});
+Object.defineProperty(exports, "isObject", {
+	enumerable: true,
+	get: () => radashi.isObject
+});
+Object.defineProperty(exports, "isPlainObject", {
+	enumerable: true,
+	get: () => radashi.isPlainObject
+});
+Object.defineProperty(exports, "isPrimitive", {
+	enumerable: true,
+	get: () => radashi.isPrimitive
+});
+Object.defineProperty(exports, "isPromise", {
+	enumerable: true,
+	get: () => radashi.isPromise
+});
+Object.defineProperty(exports, "isRegExp", {
+	enumerable: true,
+	get: () => radashi.isRegExp
+});
+Object.defineProperty(exports, "isSet", {
+	enumerable: true,
+	get: () => radashi.isSet
+});
+Object.defineProperty(exports, "isString", {
+	enumerable: true,
+	get: () => radashi.isString
+});
+Object.defineProperty(exports, "isSymbol", {
+	enumerable: true,
+	get: () => radashi.isSymbol
+});
+Object.defineProperty(exports, "isUndefined", {
+	enumerable: true,
+	get: () => radashi.isUndefined
+});
+Object.defineProperty(exports, "isWeakMap", {
+	enumerable: true,
+	get: () => radashi.isWeakMap
+});
+Object.defineProperty(exports, "isWeakSet", {
+	enumerable: true,
+	get: () => radashi.isWeakSet
+});
+Object.defineProperty(exports, "kebabCase", {
+	enumerable: true,
+	get: () => radashi.dash
+});
+Object.defineProperty(exports, "last", {
+	enumerable: true,
+	get: () => radashi.last
+});
+Object.defineProperty(exports, "max", {
+	enumerable: true,
+	get: () => radashi.max
+});
+Object.defineProperty(exports, "memoize", {
+	enumerable: true,
+	get: () => radashi.memo
+});
+Object.defineProperty(exports, "min", {
+	enumerable: true,
+	get: () => radashi.min
+});
+Object.defineProperty(exports, "noop", {
+	enumerable: true,
+	get: () => radashi.noop
+});
+Object.defineProperty(exports, "omit", {
+	enumerable: true,
+	get: () => radashi.omit
+});
+Object.defineProperty(exports, "once", {
+	enumerable: true,
+	get: () => radashi.once
+});
+Object.defineProperty(exports, "pascalCase", {
+	enumerable: true,
+	get: () => radashi.pascal
+});
+Object.defineProperty(exports, "pick", {
+	enumerable: true,
+	get: () => radashi.pick
+});
+Object.defineProperty(exports, "set", {
+	enumerable: true,
+	get: () => radashi.set
+});
+Object.defineProperty(exports, "similarity", {
+	enumerable: true,
+	get: () => radashi.similarity
+});
+Object.defineProperty(exports, "snakeCase", {
+	enumerable: true,
+	get: () => radashi.snake
+});
+Object.defineProperty(exports, "sum", {
+	enumerable: true,
+	get: () => radashi.sum
+});
+Object.defineProperty(exports, "template", {
+	enumerable: true,
+	get: () => radashi.template
+});
+Object.defineProperty(exports, "throttle", {
+	enumerable: true,
+	get: () => radashi.throttle
+});
+Object.defineProperty(exports, "toFloat", {
+	enumerable: true,
+	get: () => radashi.toFloat
+});
+Object.defineProperty(exports, "toInt", {
+	enumerable: true,
+	get: () => radashi.toInt
+});
+Object.defineProperty(exports, "trim", {
+	enumerable: true,
+	get: () => radashi.trim
+});
+Object.defineProperty(exports, "unique", {
+	enumerable: true,
+	get: () => radashi.unique
+});
+exports.alwaysFalse = lib.alwaysFalse;
+exports.alwaysTrue = lib.alwaysTrue;
+exports.mergeWith = object.mergeWith;
+exports.formatPath = path.formatPath;
+exports.getBaseName = path.getBaseName;
+exports.getDirName = path.getDirName;
+exports.getExtName = path.getExtName;
+exports.getRelativePath = path.getRelativePath;
+exports.isAbsolutePath = path.isAbsolutePath;
+exports.joinPaths = path.joinPaths;
+exports.normalizePath = path.normalizePath;
+exports.parsePath = path.parsePath;
+exports.pathSeparator = path.pathSeparator;
+exports.resolvePath = path.resolvePath;
+exports.getPinyin = pinyin.getPinyin;
+exports.getPinyinInitials = pinyin.getPinyinInitials;
+exports.withPinyin = pinyin.withPinyin;
+exports.decryptUsingRSA = security.decryptUsingRSA;
+exports.encryptUsingRSA = security.encryptUsingRSA;
+exports.constantCase = string.constantCase;
+exports.scheduleMicrotask = task.scheduleMicrotask;
+exports.buildTree = tree.buildTree;
+exports.filterTree = tree.filterTree;
+exports.filterTreeWithAncestors = tree.filterTreeWithAncestors;
+exports.findNodeInTree = tree.findNodeInTree;
+exports.flattenTree = tree.flattenTree;
+exports.mapTree = tree.mapTree;
+exports.traverseTree = tree.traverseTree;
+Object.defineProperty(exports, "z", {
+	enumerable: true,
+	get: () => zod.z
+});

package/dist/cjs/types/color.cjs

@@ -0,0 +1,3 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+

package/dist/cjs/types/common.cjs

@@ -0,0 +1,3 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+

package/dist/cjs/types/deep-keys.cjs

@@ -0,0 +1,3 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+

package/dist/cjs/types/index.cjs

@@ -0,0 +1,7 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+
+require('./color.cjs');
+require('./common.cjs');
+require('./deep-keys.cjs');
+

package/dist/cjs/utils/chrono.cjs

@@ -0,0 +1,139 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const dayjs = require('dayjs');
+const locale = require('dayjs/locale/zh-cn');
+const customParseFormat = require('dayjs/plugin/customParseFormat');
+const duration = require('dayjs/plugin/duration');
+const localizedFormat = require('dayjs/plugin/localizedFormat');
+const relativeTime = require('dayjs/plugin/relativeTime');
+
+dayjs.locale(locale);
+dayjs.extend(localizedFormat);
+dayjs.extend(customParseFormat);
+dayjs.extend(duration);
+dayjs.extend(relativeTime);
+const DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
+const DEFAULT_TIME_FORMAT = "HH:mm:ss";
+const DEFAULT_DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
+const LOCALIZED_DATETIME_FORMAT = "LLLL";
+const LOCALIZED_DATE_FORMAT = "LLdddd";
+const YEAR_FORMATS = ["YYYY"];
+const QUARTER_FORMATS = ["YYYY-Q季度"];
+const MONTH_FORMATS = [
+  "YYYY-MM",
+  "YYYY/MM",
+  "YYYY.MM",
+  "YYYYMM"
+];
+const WEEK_FORMATS = ["YYYY-wo"];
+const DATE_FORMATS = [
+  "YYYY-MM-DD",
+  "YYYY/MM/DD",
+  "YYYY.MM.DD",
+  "YYYYMMDD",
+  "YY/MM/DD",
+  "YY.MM.DD",
+  "YYMMDD"
+];
+const TIME_FORMATS = ["HH:mm:ss", "HH.mm.ss", "HHmmss"];
+const HOUR_FORMATS = ["HH"];
+const MINUTE_FORMATS = ["HH:mm", "HH.mm", "HHmm"];
+const DATETIME_FORMATS = [
+  "YYYY-MM-DD HH:mm:ss",
+  "YYYY/MM/DD HH:mm:ss",
+  "YYYY.MM.DD HH.mm.ss",
+  "YYYYMMDDHHmmss",
+  "YY/MM/DD HH:mm:ss",
+  "YY.MM.DD HH:mm:ss",
+  "YY.MM.DD HH.mm.ss",
+  "YYMMDDHHmmss"
+];
+function formatDuration(seconds, unit = "seconds") {
+  const duration2 = dayjs.duration(seconds, unit);
+  const days = Math.floor(duration2.asDays());
+  const hours = duration2.hours();
+  const minutes = duration2.minutes();
+  if (days > 0) {
+    return `${days}天${hours}小时${minutes}分钟`;
+  }
+  if (hours > 0) {
+    return `${hours}小时${minutes}分钟`;
+  }
+  return `${minutes}分钟`;
+}
+function parseDate(date, format = DEFAULT_DATETIME_FORMAT) {
+  if (date instanceof Date) {
+    return dayjs(date);
+  }
+  return format ? dayjs(date, format) : dayjs(date);
+}
+function tryParseDate(date) {
+  for (const format of DATETIME_FORMATS) {
+    const parsed = dayjs(date, format, true);
+    if (parsed.isValid()) {
+      return parsed;
+    }
+  }
+  for (const format of DATE_FORMATS) {
+    const parsed = dayjs(date, format, true);
+    if (parsed.isValid()) {
+      return parsed;
+    }
+  }
+  const defaultParsed = dayjs(date);
+  if (defaultParsed.isValid()) {
+    return defaultParsed;
+  }
+  return null;
+}
+function formatDate(date, format = DEFAULT_DATETIME_FORMAT) {
+  return date.format(format);
+}
+function getNow() {
+  return dayjs();
+}
+function getNowDateString() {
+  return dayjs().format(DEFAULT_DATE_FORMAT);
+}
+function getNowTimeString() {
+  return dayjs().format(DEFAULT_TIME_FORMAT);
+}
+function getNowDateTimeString() {
+  return dayjs().format(DEFAULT_DATETIME_FORMAT);
+}
+function getLocalizedDateTime(includeTime = true) {
+  return dayjs().format(includeTime ? LOCALIZED_DATETIME_FORMAT : LOCALIZED_DATE_FORMAT);
+}
+const FORMAT_MAP = {
+  year: YEAR_FORMATS,
+  quarter: QUARTER_FORMATS,
+  month: MONTH_FORMATS,
+  week: WEEK_FORMATS,
+  date: DATE_FORMATS,
+  time: TIME_FORMATS,
+  hour: HOUR_FORMATS,
+  minute: MINUTE_FORMATS,
+  datetime: DATETIME_FORMATS
+};
+function getTemporalFormats(mode) {
+  return FORMAT_MAP[mode];
+}
+
+exports.DEFAULT_DATETIME_FORMAT = DEFAULT_DATETIME_FORMAT;
+exports.DEFAULT_DATE_FORMAT = DEFAULT_DATE_FORMAT;
+exports.DEFAULT_TIME_FORMAT = DEFAULT_TIME_FORMAT;
+exports.LOCALIZED_DATETIME_FORMAT = LOCALIZED_DATETIME_FORMAT;
+exports.LOCALIZED_DATE_FORMAT = LOCALIZED_DATE_FORMAT;
+exports.formatDate = formatDate;
+exports.formatDuration = formatDuration;
+exports.getLocalizedDateTime = getLocalizedDateTime;
+exports.getNow = getNow;
+exports.getNowDateString = getNowDateString;
+exports.getNowDateTimeString = getNowDateTimeString;
+exports.getNowTimeString = getNowTimeString;
+exports.getTemporalFormats = getTemporalFormats;
+exports.parseDate = parseDate;
+exports.tryParseDate = tryParseDate;

package/dist/cjs/utils/equal.cjs

@@ -0,0 +1,175 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function isShallowEqual(value1, value2) {
+  if (Object.is(value1, value2)) {
+    return true;
+  }
+  if (typeof value1 !== "object" || value1 === null || typeof value2 !== "object" || value2 === null) {
+    return false;
+  }
+  if (value1 instanceof Map && value2 instanceof Map) {
+    if (value1.size !== value2.size) {
+      return false;
+    }
+    for (const [k, v] of value1) {
+      if (!value2.has(k) || !Object.is(v, value2.get(k))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (value1 instanceof Set && value2 instanceof Set) {
+    if (value1.size !== value2.size) {
+      return false;
+    }
+    for (const v of value1) {
+      if (!value2.has(v)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const isArray1 = Array.isArray(value1);
+  const isArray2 = Array.isArray(value2);
+  if (isArray1 !== isArray2) {
+    return false;
+  }
+  if (value1.constructor !== value2.constructor) {
+    return false;
+  }
+  const keysA = Object.keys(value1);
+  if (keysA.length !== Object.keys(value2).length) {
+    return false;
+  }
+  for (const element of keysA) {
+    if (!Object.hasOwn(value2, element) || !Object.is(value1[element], value2[element])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isDeepEqual(value1, value2) {
+  const { valueOf, toString } = Object.prototype;
+  const visited = /* @__PURE__ */ new WeakMap();
+  const compareValues = (currentFirst, currentSecond) => {
+    if (currentFirst === currentSecond) {
+      return true;
+    }
+    if (typeof currentFirst !== "object" || typeof currentSecond !== "object" || !currentFirst || !currentSecond) {
+      return currentFirst !== currentFirst && currentSecond !== currentSecond;
+    }
+    if (Object.getPrototypeOf(currentFirst) !== Object.getPrototypeOf(currentSecond)) {
+      return false;
+    }
+    const { constructor } = currentFirst;
+    if (constructor === Date) {
+      return currentFirst.getTime() === currentSecond.getTime();
+    }
+    if (constructor === RegExp) {
+      const firstRegex = currentFirst;
+      const secondRegex = currentSecond;
+      return firstRegex.source === secondRegex.source && firstRegex.flags === secondRegex.flags;
+    }
+    if (constructor === Set) {
+      const firstSet = currentFirst;
+      const secondSet = currentSecond;
+      if (firstSet.size !== secondSet.size) {
+        return false;
+      }
+      for (const value of firstSet) {
+        let found = false;
+        for (const secondValue of secondSet) {
+          if (compareValues(value, secondValue)) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (constructor === ArrayBuffer) {
+      const firstView = new DataView(currentFirst);
+      const secondView = new DataView(currentSecond);
+      return compareValues(firstView, secondView);
+    }
+    if (constructor === DataView || ArrayBuffer.isView(currentFirst)) {
+      let firstView;
+      let secondView;
+      if (constructor === DataView) {
+        firstView = currentFirst;
+        secondView = currentSecond;
+      } else {
+        const firstTyped = currentFirst;
+        const secondTyped = currentSecond;
+        firstView = new DataView(firstTyped.buffer, firstTyped.byteOffset, firstTyped.byteLength);
+        secondView = new DataView(secondTyped.buffer, secondTyped.byteOffset, secondTyped.byteLength);
+      }
+      if (firstView.byteLength !== secondView.byteLength) {
+        return false;
+      }
+      for (let index = firstView.byteLength; index-- !== 0; ) {
+        if (firstView.getUint8(index) !== secondView.getUint8(index)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (visited.has(currentFirst) && visited.get(currentFirst) === currentSecond) {
+      return true;
+    }
+    visited.set(currentFirst, currentSecond);
+    if (constructor === Array) {
+      const firstArray = currentFirst;
+      const secondArray = currentSecond;
+      if (firstArray.length !== secondArray.length) {
+        return false;
+      }
+      for (let index = firstArray.length; index-- !== 0; ) {
+        if (!compareValues(firstArray[index], secondArray[index])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (constructor === Map) {
+      const firstMap = currentFirst;
+      const secondMap = currentSecond;
+      if (firstMap.size !== secondMap.size) {
+        return false;
+      }
+      for (const [key, value] of firstMap) {
+        if (!secondMap.has(key) || !compareValues(value, secondMap.get(key))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const firstAsAny = currentFirst;
+    const secondAsAny = currentSecond;
+    if (firstAsAny.valueOf !== valueOf && typeof firstAsAny.valueOf === "function" && typeof secondAsAny.valueOf === "function") {
+      return firstAsAny.valueOf() === secondAsAny.valueOf();
+    }
+    if (firstAsAny.toString !== toString && typeof firstAsAny.toString === "function" && typeof secondAsAny.toString === "function") {
+      return firstAsAny.toString() === secondAsAny.toString();
+    }
+    const firstKeys = Object.keys(currentFirst);
+    let currentKey;
+    for (let index = firstKeys.length; index-- !== 0; ) {
+      currentKey = firstKeys[index];
+      if (!Object.hasOwn(currentSecond, currentKey) || !compareValues(firstAsAny[currentKey], secondAsAny[currentKey])) {
+        return false;
+      }
+    }
+    return Object.keys(currentSecond).length === firstKeys.length;
+  };
+  return compareValues(value1, value2);
+}
+
+exports.isDeepEqual = isDeepEqual;
+exports.isShallowEqual = isShallowEqual;