umt 2.12.3 → 2.14.0

package/module/es5/Number/formatNumber.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatNumber = void 0;
+/**
+ * Options for formatting a number.
+ */
+
+/**
+ * Formats a number using Intl.NumberFormat.
+ *
+ * @param value - The number to format
+ * @param options - Formatting options
+ * @returns The formatted number string
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1234567.89);
+ * // "1,234,567.89" (in en-US locale)
+ *
+ * formatNumber(1234567.89, { locale: "de-DE" });
+ * // "1.234.567,89"
+ *
+ * formatNumber(0.75, { style: "percent" });
+ * // "75%"
+ *
+ * formatNumber(1234.5, {
+ *   style: "currency",
+ *   currency: "USD",
+ *   locale: "en-US",
+ * });
+ * // "$1,234.50"
+ * ```
+ */
+var formatNumber = exports.formatNumber = function formatNumber(value) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var locale = options.locale,
+    minimumFractionDigits = options.minimumFractionDigits,
+    maximumFractionDigits = options.maximumFractionDigits,
+    style = options.style,
+    currency = options.currency;
+  var formatOptions = {};
+  if (style !== undefined) {
+    formatOptions.style = style;
+  }
+  if (currency !== undefined) {
+    formatOptions.currency = currency;
+  }
+  if (minimumFractionDigits !== undefined) {
+    formatOptions.minimumFractionDigits = minimumFractionDigits;
+  }
+  if (maximumFractionDigits !== undefined) {
+    formatOptions.maximumFractionDigits = maximumFractionDigits;
+  }
+  return new Intl.NumberFormat(locale, formatOptions).format(value);
+};

package/module/es5/Number/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./formatNumber";
+export * from "./toOrdinal";
+export * from "./toPercentage";

package/module/es5/Number/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _formatNumber = require("./formatNumber");
+Object.keys(_formatNumber).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _formatNumber[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _formatNumber[key];
+    }
+  });
+});
+var _toOrdinal = require("./toOrdinal");
+Object.keys(_toOrdinal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toOrdinal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toOrdinal[key];
+    }
+  });
+});
+var _toPercentage = require("./toPercentage");
+Object.keys(_toPercentage).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _toPercentage[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _toPercentage[key];
+    }
+  });
+});

package/module/es5/Number/toOrdinal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a number to its English ordinal string representation.
+ *
+ * Handles the special cases for 11th, 12th, and 13th
+ * (which end in "th" despite their last digit).
+ *
+ * @param value - The number to convert to ordinal form
+ * @returns The ordinal string (e.g., "1st", "2nd", "3rd", "11th")
+ *
+ * @example
+ * ```typescript
+ * toOrdinal(1);   // "1st"
+ * toOrdinal(2);   // "2nd"
+ * toOrdinal(3);   // "3rd"
+ * toOrdinal(11);  // "11th"
+ * toOrdinal(21);  // "21st"
+ * toOrdinal(112); // "112th"
+ * ```
+ */
+export declare const toOrdinal: (value: number) => string;

package/module/es5/Number/toOrdinal.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toOrdinal = void 0;
+/**
+ * Converts a number to its English ordinal string representation.
+ *
+ * Handles the special cases for 11th, 12th, and 13th
+ * (which end in "th" despite their last digit).
+ *
+ * @param value - The number to convert to ordinal form
+ * @returns The ordinal string (e.g., "1st", "2nd", "3rd", "11th")
+ *
+ * @example
+ * ```typescript
+ * toOrdinal(1);   // "1st"
+ * toOrdinal(2);   // "2nd"
+ * toOrdinal(3);   // "3rd"
+ * toOrdinal(11);  // "11th"
+ * toOrdinal(21);  // "21st"
+ * toOrdinal(112); // "112th"
+ * ```
+ */
+var toOrdinal = exports.toOrdinal = function toOrdinal(value) {
+  var module100 = value % 100;
+  if (module100 >= 11 && module100 <= 13) {
+    return "".concat(value, "th");
+  }
+  var module10 = value % 10;
+  if (module10 === 1) {
+    return "".concat(value, "st");
+  }
+  if (module10 === 2) {
+    return "".concat(value, "nd");
+  }
+  if (module10 === 3) {
+    return "".concat(value, "rd");
+  }
+  return "".concat(value, "th");
+};

package/module/es5/Number/toPercentage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Calculates the percentage of a value relative to a total.
+ *
+ * Returns 0 when the total is 0 to avoid division by zero.
+ *
+ * @param value - The partial value
+ * @param total - The total value
+ * @param decimals - The number of decimal places (default 2)
+ * @returns The percentage value
+ *
+ * @example
+ * ```typescript
+ * toPercentage(25, 100);      // 25
+ * toPercentage(1, 3);         // 33.33
+ * toPercentage(1, 3, 0);      // 33
+ * toPercentage(0, 0);         // 0
+ * toPercentage(50, 200, 1);   // 25.0 -> 25
+ * ```
+ */
+export declare const toPercentage: (value: number, total: number, decimals?: number) => number;

package/module/es5/Number/toPercentage.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toPercentage = void 0;
+/**
+ * Calculates the percentage of a value relative to a total.
+ *
+ * Returns 0 when the total is 0 to avoid division by zero.
+ *
+ * @param value - The partial value
+ * @param total - The total value
+ * @param decimals - The number of decimal places (default 2)
+ * @returns The percentage value
+ *
+ * @example
+ * ```typescript
+ * toPercentage(25, 100);      // 25
+ * toPercentage(1, 3);         // 33.33
+ * toPercentage(1, 3, 0);      // 33
+ * toPercentage(0, 0);         // 0
+ * toPercentage(50, 200, 1);   // 25.0 -> 25
+ * ```
+ */
+var toPercentage = exports.toPercentage = function toPercentage(value, total) {
+  var decimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
+  if (total === 0) {
+    return 0;
+  }
+  var factor = Math.pow(10, decimals);
+  return Math.round(value / total * 100 * factor) / factor;
+};

package/module/es5/Object/deepClone.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a deep clone of the given value.
+ *
+ * @param value - The value to deep clone.
+ * @returns A deep clone of the input value.
+ *
+ * @example
+ * ```typescript
+ * const original = { a: 1, b: { c: 2 } };
+ * const cloned = deepClone(original);
+ * cloned.b.c = 99;
+ * original.b.c; // still 2
+ * ```
+ */
+export declare const deepClone: <T>(value: T) => T;

package/module/es5/Object/deepClone.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepClone = void 0;
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/**
+ * Recursively clones a value.
+ */
+var _cloneValue = function cloneValue(value) {
+  if (value === null || _typeof(value) !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    var _result = [];
+    var _iterator = _createForOfIteratorHelper(value),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var element = _step.value;
+        _result.push(_cloneValue(element));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return _result;
+  }
+  if (value instanceof Date) {
+    return new Date(value);
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (value instanceof Map) {
+    var _result2 = new Map();
+    var _iterator2 = _createForOfIteratorHelper(value),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _slicedToArray(_step2.value, 2),
+          k = _step2$value[0],
+          v = _step2$value[1];
+        _result2.set(_cloneValue(k), _cloneValue(v));
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return _result2;
+  }
+  if (value instanceof Set) {
+    var _result3 = new Set();
+    var _iterator3 = _createForOfIteratorHelper(value),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _v = _step3.value;
+        _result3.add(_cloneValue(_v));
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    return _result3;
+  }
+
+  // Plain object
+  var result = {};
+  for (var _i = 0, _Object$keys = Object.keys(value); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
+    result[key] = _cloneValue(value[key]);
+  }
+  return result;
+};
+
+/**
+ * Creates a deep clone of the given value.
+ *
+ * @param value - The value to deep clone.
+ * @returns A deep clone of the input value.
+ *
+ * @example
+ * ```typescript
+ * const original = { a: 1, b: { c: 2 } };
+ * const cloned = deepClone(original);
+ * cloned.b.c = 99;
+ * original.b.c; // still 2
+ * ```
+ */
+var deepClone = exports.deepClone = function deepClone(value) {
+  if (value === null || _typeof(value) !== "object") {
+    return value;
+  }
+  return _cloneValue(value);
+};

package/module/es5/Object/getObjectsCommon.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Extract key-value pairs common to all input objects.
+ *
+ * A key-value pair is considered common when the key exists in every object
+ * and the value is strictly equal (===) across all objects.
+ * When all values for a key are plain objects, the function recurses to find
+ * the common subset. If the recursive result is empty, the key is excluded.
+ *
+ * @template T - Type of the input objects.
+ * @param {T} object - The first object.
+ * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
+ * @returns {Partial<T>} Object containing only the key-value pairs shared by all inputs.
+ *
+ * @example
+ * ```typescript
+ * getObjectsCommon({ a: 1, b: 2 }, { a: 1, c: 3 });
+ * // { a: 1 }
+ *
+ * getObjectsCommon({ a: { b: 1, c: 2 }, d: 3 }, { a: { b: 1, d: 4 }, d: 3 });
+ * // { a: { b: 1 }, d: 3 }
+ * ```
+ */
+export declare const getObjectsCommon: <T extends Record<string, unknown>>(object: T, ...objects: Record<string, unknown>[]) => Partial<T>;

package/module/es5/Object/getObjectsCommon.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getObjectsCommon = void 0;
+var _isPlainObject = require("../Object/isPlainObject");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Extract key-value pairs common to all input objects.
+ *
+ * A key-value pair is considered common when the key exists in every object
+ * and the value is strictly equal (===) across all objects.
+ * When all values for a key are plain objects, the function recurses to find
+ * the common subset. If the recursive result is empty, the key is excluded.
+ *
+ * @template T - Type of the input objects.
+ * @param {T} object - The first object.
+ * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
+ * @returns {Partial<T>} Object containing only the key-value pairs shared by all inputs.
+ *
+ * @example
+ * ```typescript
+ * getObjectsCommon({ a: 1, b: 2 }, { a: 1, c: 3 });
+ * // { a: 1 }
+ *
+ * getObjectsCommon({ a: { b: 1, c: 2 }, d: 3 }, { a: { b: 1, d: 4 }, d: 3 });
+ * // { a: { b: 1 }, d: 3 }
+ * ```
+ */
+var _getObjectsCommon = exports.getObjectsCommon = function getObjectsCommon(object) {
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    objects[_key - 1] = arguments[_key];
+  }
+  if (objects.length === 0) {
+    return _objectSpread({}, object);
+  }
+  var result = {};
+  var _loop = function _loop() {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var isCommon = true;
+    var allPlainObjects = (0, _isPlainObject.isPlainObject)(value);
+    for (var _i2 = 0, _objects = objects; _i2 < _objects.length; _i2++) {
+      var other = _objects[_i2];
+      if (!Object.hasOwn(other, key)) {
+        isCommon = false;
+        break;
+      }
+      if (!(0, _isPlainObject.isPlainObject)(other[key])) {
+        allPlainObjects = false;
+      }
+      if (!allPlainObjects && other[key] !== value) {
+        isCommon = false;
+        break;
+      }
+    }
+    if (!isCommon) {
+      return 1; // continue
+    }
+    if (allPlainObjects) {
+      var nested = _getObjectsCommon.apply(void 0, [value].concat(_toConsumableArray(objects.map(function (other) {
+        return other[key];
+      }))));
+      if (Object.keys(nested).length > 0) {
+        result[key] = nested;
+      }
+    } else {
+      result[key] = value;
+    }
+  };
+  for (var _i = 0, _Object$entries = Object.entries(object); _i < _Object$entries.length; _i++) {
+    if (_loop()) continue;
+  }
+  return result;
+};

package/module/es5/Object/getObjectsDiff.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Extract key-value pairs that appear in exactly one input object.
+ *
+ * A key-value pair is considered "shared" if the same key with the same value (===)
+ * exists in two or more objects. Only pairs unique to a single object are returned.
+ * When all values for a key are plain objects, the function recurses to find
+ * the diff subset. If the recursive result is empty, the key is excluded.
+ * When multiple unique pairs share the same key (different values),
+ * the last value wins.
+ *
+ * @template T - Type of the input objects.
+ * @param {T} object - The first object.
+ * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
+ * @returns {Partial<T>} Object containing only key-value pairs unique to one input.
+ *
+ * @example
+ * ```typescript
+ * getObjectsDiff({ a: 1, b: 2 }, { b: 2, c: 3 });
+ * // { a: 1, c: 3 }
+ *
+ * getObjectsDiff({ a: { b: 1, c: 2 }, d: 3 }, { a: { b: 1, d: 4 }, d: 3 });
+ * // { a: { c: 2, d: 4 } }
+ * ```
+ */
+export declare const getObjectsDiff: <T extends Record<string, unknown>>(object: T, ...objects: Record<string, unknown>[]) => Partial<T>;

package/module/es5/Object/getObjectsDiff.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getObjectsDiff = void 0;
+var _isPlainObject = require("../Object/isPlainObject");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Extract key-value pairs that appear in exactly one input object.
+ *
+ * A key-value pair is considered "shared" if the same key with the same value (===)
+ * exists in two or more objects. Only pairs unique to a single object are returned.
+ * When all values for a key are plain objects, the function recurses to find
+ * the diff subset. If the recursive result is empty, the key is excluded.
+ * When multiple unique pairs share the same key (different values),
+ * the last value wins.
+ *
+ * @template T - Type of the input objects.
+ * @param {T} object - The first object.
+ * @param {...Record<string, unknown>[]} objects - Additional objects to compare.
+ * @returns {Partial<T>} Object containing only key-value pairs unique to one input.
+ *
+ * @example
+ * ```typescript
+ * getObjectsDiff({ a: 1, b: 2 }, { b: 2, c: 3 });
+ * // { a: 1, c: 3 }
+ *
+ * getObjectsDiff({ a: { b: 1, c: 2 }, d: 3 }, { a: { b: 1, d: 4 }, d: 3 });
+ * // { a: { c: 2, d: 4 } }
+ * ```
+ */
+var _getObjectsDiff = exports.getObjectsDiff = function getObjectsDiff(object) {
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    objects[_key - 1] = arguments[_key];
+  }
+  var allObjects = [object].concat(objects);
+  if (allObjects.length === 1) {
+    return _objectSpread({}, object);
+  }
+  var allKeys = new Set();
+  var _iterator = _createForOfIteratorHelper(allObjects),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var object_ = _step.value;
+      for (var _i = 0, _Object$keys = Object.keys(object_); _i < _Object$keys.length; _i++) {
+        var key = _Object$keys[_i];
+        allKeys.add(key);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var result = {};
+  var _iterator2 = _createForOfIteratorHelper(allKeys),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _key2 = _step2.value;
+      var values = [];
+      var presentIn = [];
+      var _iterator3 = _createForOfIteratorHelper(allObjects.entries()),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _step3$value = _slicedToArray(_step3.value, 2),
+            index = _step3$value[0],
+            currentObject = _step3$value[1];
+          if (Object.hasOwn(currentObject, _key2)) {
+            values.push(currentObject[_key2]);
+            presentIn.push(index);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      if (values.length === 1) {
+        result[_key2] = values[0];
+        continue;
+      }
+      var allPlain = values.every(function (value) {
+        return (0, _isPlainObject.isPlainObject)(value);
+      });
+      if (allPlain) {
+        var nested = _getObjectsDiff.apply(void 0, [values[0]].concat(_toConsumableArray(values.slice(1))));
+        if (Object.keys(nested).length > 0) {
+          result[_key2] = nested;
+        }
+        continue;
+      }
+      var lastUniqueValue = void 0;
+      var hasUnique = false;
+      for (var _i2 = 0, _values = values; _i2 < _values.length; _i2++) {
+        var value = _values[_i2];
+        var count = 0;
+        var _iterator4 = _createForOfIteratorHelper(values),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var other = _step4.value;
+            if (value === other) {
+              count++;
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+        if (count === 1) {
+          lastUniqueValue = value;
+          hasUnique = true;
+        }
+      }
+      if (hasUnique) {
+        result[_key2] = lastUniqueValue;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return result;
+};

package/module/es5/Object/index.d.ts

@@ -1,6 +1,12 @@
+export * from "./deepClone";
+export * from "./getObjectsCommon";
+export * from "./getObjectsDiff";
 export * from "./has";
 export * from "./isEmpty";
+export * from "./isPlainObject";
 export * from "./keyBy";
+export * from "./mapKeys";
+export * from "./mapValues";
 export * from "./merge";
 export * from "./mergeDeep";
 export * from "./omit";