umt 2.16.0 → 2.17.0

package/module/es5/Date/subDuration.d.ts

@@ -0,0 +1,13 @@
+import type { DurationUnit } from "./durationUnit";
+/**
+ * Subtracts a duration from a date and returns a new Date.
+ * Equivalent to addDuration(date, -amount, unit).
+ *
+ * @param {Date} date - Base date
+ * @param {number} amount - Amount to subtract
+ * @param {DurationUnit} unit - Unit of the amount
+ * @returns {Date} A new Date with the duration subtracted
+ * @example
+ * subDuration(new Date("2025-03-31"), 1, "M"); // 2025-02-28
+ */
+export declare const subDuration: (date: Date, amount: number, unit: DurationUnit) => Date;

package/module/es5/Date/subDuration.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subDuration = void 0;
+var _addDuration = require("./addDuration");
+/**
+ * Subtracts a duration from a date and returns a new Date.
+ * Equivalent to addDuration(date, -amount, unit).
+ *
+ * @param {Date} date - Base date
+ * @param {number} amount - Amount to subtract
+ * @param {DurationUnit} unit - Unit of the amount
+ * @returns {Date} A new Date with the duration subtracted
+ * @example
+ * subDuration(new Date("2025-03-31"), 1, "M"); // 2025-02-28
+ */
+var subDuration = exports.subDuration = function subDuration(date, amount, unit) {
+  return (0, _addDuration.addDuration)(date, -amount, unit);
+};

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

@@ -1,5 +1,4 @@
 export * from "./flatMapResult";
 export * from "./mapResult";
 export * from "./matchResult";
-export * from "./retry";
 export * from "./safeExecute";

package/module/es5/Error/index.js

@@ -36,17 +36,6 @@ Object.keys(_matchResult).forEach(function (key) {
     }
   });
 });
-var _retry = require("./retry");
-Object.keys(_retry).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _retry[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _retry[key];
-    }
-  });
-});
 var _safeExecute = require("./safeExecute");
 Object.keys(_safeExecute).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

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

@@ -0,0 +1,11 @@
+/**
+ * Recursively flattens a nested plain object into a single-level object
+ * keyed by joined paths. Arrays and non-plain objects are kept as-is.
+ *
+ * @param {Record<string, unknown>} object - Source nested object
+ * @param {string} [separator="."] - Separator used to join path segments
+ * @returns {Record<string, unknown>} A flat object
+ * @example
+ * flattenObject({ a: { b: { c: 1 } }, d: 2 }); // { "a.b.c": 1, d: 2 }
+ */
+export declare const flattenObject: <T extends Record<string, unknown>>(object: T, separator?: string) => Record<string, unknown>;

package/module/es5/Object/flattenObject.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenObject = void 0;
+var _isPlainObject = require("./isPlainObject");
+/**
+ * Recursively flattens a nested plain object into a single-level object
+ * keyed by joined paths. Arrays and non-plain objects are kept as-is.
+ *
+ * @param {Record<string, unknown>} object - Source nested object
+ * @param {string} [separator="."] - Separator used to join path segments
+ * @returns {Record<string, unknown>} A flat object
+ * @example
+ * flattenObject({ a: { b: { c: 1 } }, d: 2 }); // { "a.b.c": 1, d: 2 }
+ */
+var flattenObject = exports.flattenObject = function flattenObject(object) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ".";
+  var result = {};
+  var _walk = function walk(current, prefix) {
+    for (var _i = 0, _Object$keys = Object.keys(current); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      var value = current[key];
+      var nextKey = prefix ? "".concat(prefix).concat(separator).concat(key) : key;
+      if ((0, _isPlainObject.isPlainObject)(value) && Object.keys(value).length > 0) {
+        _walk(value, nextKey);
+      } else {
+        result[nextKey] = value;
+      }
+    }
+  };
+  _walk(object, "");
+  return result;
+};

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

@@ -0,0 +1 @@
+export declare const get: <T>(object: unknown, path: string | string[], defaultValue?: T) => T | undefined;

package/module/es5/Object/get.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.get = void 0;
+var _pathSegments = require("./pathSegments");
+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; } /**
+ * Reads a deeply nested property by string or string-array path.
+ * Returns the default value if any segment is missing.
+ *
+ * @template T - Expected return type
+ * @param {unknown} object - Source object
+ * @param {string | string[]} path - Dot-separated string or path segments array
+ * @param {T} [defaultValue] - Returned when the path resolves to undefined or is missing
+ * @returns {T | undefined} The resolved value, or defaultValue when missing
+ * @example
+ * get({ a: { b: { c: 1 } } }, "a.b.c"); // 1
+ * get({ a: { b: 1 } }, ["a", "x"], 0); // 0
+ */
+var get = exports.get = function get(object, path, defaultValue) {
+  var segments = (0, _pathSegments.pathSegments)(path);
+  var current = object;
+  var _iterator = _createForOfIteratorHelper(segments),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      if (current == null) {
+        return defaultValue;
+      }
+      current = current[key];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return current === undefined ? defaultValue : current;
+};

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

@@ -1,22 +1,3 @@
-/**
- * Determines if an object has a specified path
- * @param {T} object - Object to check
- * @param {string | string[]} path - Path to check
- * @returns {boolean} Returns true if path exists, false otherwise
- * @example has({ a: { b: 1 } }, "a.b"); // true
- * has({ a: { b: 1 } }, ["a", "b"]); // true
- * has({ a: { b: 1 } }, "a.c"); // false
- *
- * @remarks
- * **Prototype pollution warning:** This function does not filter out
- * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
- * If processing user-controlled input, sanitize with the appropriate
- * `removePrototype*` helper before calling this function:
- * - `removePrototype` — shallow sanitization of a single object
- * - `removePrototypeDeep` — recursive sanitization of a single object (for deeply nested data)
- * - `removePrototypeMap` — shallow sanitization of an array of objects
- * - `removePrototypeMapDeep` — recursive sanitization of an array of objects (for deeply nested data)
- */
 export declare const has: <T extends {
     [key: string]: unknown;
 }>(object: T, path: string | string[]) => boolean;

package/module/es5/Object/has.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.has = void 0;
+var _pathSegments = require("./pathSegments");
 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 _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; } /**
  * Determines if an object has a specified path
  * @param {T} object - Object to check
  * @param {string | string[]} path - Path to check
@@ -27,9 +27,9 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * - `removePrototypeMapDeep` — recursive sanitization of an array of objects (for deeply nested data)
  */
 var has = exports.has = function has(object, path) {
-  var localPath = typeof path === "string" ? path.split(".") : path;
+  var segments = (0, _pathSegments.pathSegments)(path);
   var current = object;
-  var _iterator = _createForOfIteratorHelper(localPath),
+  var _iterator = _createForOfIteratorHelper(segments),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {

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

@@ -1,7 +1,10 @@
 export * from "./deepClone";
+export * from "./flattenObject";
+export * from "./get";
 export * from "./getObjectsCommon";
 export * from "./getObjectsDiff";
 export * from "./has";
+export * from "./invert";
 export * from "./isEmpty";
 export * from "./isPlainObject";
 export * from "./keyBy";
@@ -10,9 +13,14 @@ export * from "./mapValues";
 export * from "./merge";
 export * from "./mergeDeep";
 export * from "./omit";
+export * from "./omitBy";
+export * from "./pathSegments";
 export * from "./pick";
+export * from "./pickBy";
 export * from "./pickDeep";
 export * from "./removePrototype";
 export * from "./removePrototypeDeep";
 export * from "./removePrototypeMap";
 export * from "./removePrototypeMapDeep";
+export * from "./set";
+export * from "./unflattenObject";

package/module/es5/Object/index.js

@@ -14,6 +14,28 @@ Object.keys(_deepClone).forEach(function (key) {
     }
   });
 });
+var _flattenObject = require("./flattenObject");
+Object.keys(_flattenObject).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _flattenObject[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _flattenObject[key];
+    }
+  });
+});
+var _get = require("./get");
+Object.keys(_get).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _get[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _get[key];
+    }
+  });
+});
 var _getObjectsCommon = require("./getObjectsCommon");
 Object.keys(_getObjectsCommon).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -47,6 +69,17 @@ Object.keys(_has).forEach(function (key) {
     }
   });
 });
+var _invert = require("./invert");
+Object.keys(_invert).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _invert[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _invert[key];
+    }
+  });
+});
 var _isEmpty = require("./isEmpty");
 Object.keys(_isEmpty).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -135,6 +168,28 @@ Object.keys(_omit).forEach(function (key) {
     }
   });
 });
+var _omitBy = require("./omitBy");
+Object.keys(_omitBy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _omitBy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _omitBy[key];
+    }
+  });
+});
+var _pathSegments = require("./pathSegments");
+Object.keys(_pathSegments).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pathSegments[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _pathSegments[key];
+    }
+  });
+});
 var _pick = require("./pick");
 Object.keys(_pick).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -146,6 +201,17 @@ Object.keys(_pick).forEach(function (key) {
     }
   });
 });
+var _pickBy = require("./pickBy");
+Object.keys(_pickBy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pickBy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _pickBy[key];
+    }
+  });
+});
 var _pickDeep = require("./pickDeep");
 Object.keys(_pickDeep).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -200,4 +266,26 @@ Object.keys(_removePrototypeMapDeep).forEach(function (key) {
       return _removePrototypeMapDeep[key];
     }
   });
+});
+var _set = require("./set");
+Object.keys(_set).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _set[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _set[key];
+    }
+  });
+});
+var _unflattenObject = require("./unflattenObject");
+Object.keys(_unflattenObject).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _unflattenObject[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _unflattenObject[key];
+    }
+  });
 });

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

@@ -0,0 +1,12 @@
+/**
+ * Creates a new object with keys and values swapped.
+ * If multiple keys share the same value, later entries overwrite earlier ones.
+ *
+ * @template K - Key type of the input object (must be a PropertyKey)
+ * @template V - Value type of the input object (must be a PropertyKey)
+ * @param {Record<K, V>} object - Source object
+ * @returns {Record<V, K>} A new object with keys and values swapped
+ * @example
+ * invert({ a: 1, b: 2 }); // { 1: "a", 2: "b" }
+ */
+export declare const invert: <K extends PropertyKey, V extends PropertyKey>(object: Record<K, V>) => Record<V, K>;

package/module/es5/Object/invert.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.invert = void 0;
+/**
+ * Creates a new object with keys and values swapped.
+ * If multiple keys share the same value, later entries overwrite earlier ones.
+ *
+ * @template K - Key type of the input object (must be a PropertyKey)
+ * @template V - Value type of the input object (must be a PropertyKey)
+ * @param {Record<K, V>} object - Source object
+ * @returns {Record<V, K>} A new object with keys and values swapped
+ * @example
+ * invert({ a: 1, b: 2 }); // { 1: "a", 2: "b" }
+ */
+var invert = exports.invert = function invert(object) {
+  var result = {};
+  for (var _i = 0, _arr = Object.keys(object); _i < _arr.length; _i++) {
+    var key = _arr[_i];
+    var value = object[key];
+    result[value] = key;
+  }
+  return result;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Creates a new object containing only entries for which the predicate returns false.
+ *
+ * @template T - Type of the source object
+ * @param {T} object - Source object
+ * @param {(value: T[keyof T], key: keyof T) => boolean} predicate - Rejection predicate
+ * @returns {Partial<T>} A new object with the remaining entries
+ * @example
+ * omitBy({ a: 1, b: undefined, c: 3 }, (v) => v === undefined); // { a: 1, c: 3 }
+ */
+export declare const omitBy: <T extends Record<string, unknown>>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean) => Partial<T>;

package/module/es5/Object/omitBy.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.omitBy = void 0;
+/**
+ * Creates a new object containing only entries for which the predicate returns false.
+ *
+ * @template T - Type of the source object
+ * @param {T} object - Source object
+ * @param {(value: T[keyof T], key: keyof T) => boolean} predicate - Rejection predicate
+ * @returns {Partial<T>} A new object with the remaining entries
+ * @example
+ * omitBy({ a: 1, b: undefined, c: 3 }, (v) => v === undefined); // { a: 1, c: 3 }
+ */
+var omitBy = exports.omitBy = function omitBy(object, predicate) {
+  var result = {};
+  for (var _i = 0, _arr = Object.keys(object); _i < _arr.length; _i++) {
+    var key = _arr[_i];
+    var value = object[key];
+    if (!predicate(value, key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+};

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

@@ -0,0 +1 @@
+export declare const pathSegments: (path: string | string[]) => string[];

package/module/es5/Object/pathSegments.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathSegments = void 0;
+var pathSegments = exports.pathSegments = function pathSegments(path) {
+  return typeof path === "string" ? path.split(".") : path;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Creates a new object containing only entries for which the predicate returns true.
+ *
+ * @template T - Type of the source object
+ * @param {T} object - Source object
+ * @param {(value: T[keyof T], key: keyof T) => boolean} predicate - Selector predicate
+ * @returns {Partial<T>} A new object with the filtered entries
+ * @example
+ * pickBy({ a: 1, b: 2, c: 3 }, (v) => v > 1); // { b: 2, c: 3 }
+ */
+export declare const pickBy: <T extends Record<string, unknown>>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean) => Partial<T>;

package/module/es5/Object/pickBy.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pickBy = void 0;
+/**
+ * Creates a new object containing only entries for which the predicate returns true.
+ *
+ * @template T - Type of the source object
+ * @param {T} object - Source object
+ * @param {(value: T[keyof T], key: keyof T) => boolean} predicate - Selector predicate
+ * @returns {Partial<T>} A new object with the filtered entries
+ * @example
+ * pickBy({ a: 1, b: 2, c: 3 }, (v) => v > 1); // { b: 2, c: 3 }
+ */
+var pickBy = exports.pickBy = function pickBy(object, predicate) {
+  var result = {};
+  for (var _i = 0, _arr = Object.keys(object); _i < _arr.length; _i++) {
+    var key = _arr[_i];
+    var value = object[key];
+    if (predicate(value, key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+};

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

@@ -0,0 +1,19 @@
+/**
+ * Sets a value at a deeply nested path on an object, mutating it.
+ * Creates intermediate objects as needed.
+ *
+ * @template T - Type of the source object
+ * @param {T} object - Target object (mutated)
+ * @param {string | string[]} path - Dot-separated string or path segments array
+ * @param {unknown} value - Value to assign at the path
+ * @returns {T} The same object reference, for chaining
+ *
+ * @remarks
+ * **Prototype pollution warning:** This function does not filter out
+ * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
+ * Sanitize user-controlled paths before calling.
+ *
+ * @example
+ * set({}, "a.b.c", 1); // { a: { b: { c: 1 } } }
+ */
+export declare const set: <T extends object>(object: T, path: string | string[], value: unknown) => T;

package/module/es5/Object/set.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.set = void 0;
+var _pathSegments = require("./pathSegments");
+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); }
+/**
+ * Sets a value at a deeply nested path on an object, mutating it.
+ * Creates intermediate objects as needed.
+ *
+ * @template T - Type of the source object
+ * @param {T} object - Target object (mutated)
+ * @param {string | string[]} path - Dot-separated string or path segments array
+ * @param {unknown} value - Value to assign at the path
+ * @returns {T} The same object reference, for chaining
+ *
+ * @remarks
+ * **Prototype pollution warning:** This function does not filter out
+ * prototype-polluting keys (`__proto__`, `constructor`, `prototype`).
+ * Sanitize user-controlled paths before calling.
+ *
+ * @example
+ * set({}, "a.b.c", 1); // { a: { b: { c: 1 } } }
+ */
+var set = exports.set = function set(object, path, value) {
+  var segments = (0, _pathSegments.pathSegments)(path);
+  if (segments.length === 0) {
+    return object;
+  }
+  var current = object;
+  for (var index = 0; index < segments.length - 1; index += 1) {
+    var key = segments[index];
+    var next = current[key];
+    if (next == null || _typeof(next) !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  var lastIndex = segments.length - 1;
+  current[segments[lastIndex]] = value;
+  return object;
+};

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

@@ -0,0 +1,15 @@
+/**
+ * Reconstructs a nested object from a flat path-keyed object.
+ *
+ * @param {Record<string, unknown>} flat - Flat input keyed by joined paths
+ * @param {string} [separator="."] - Separator used in path keys
+ * @returns {Record<string, unknown>} A nested object
+ *
+ * @remarks
+ * **Prototype pollution warning:** Internally uses `set`, which does not
+ * filter out prototype-polluting keys. Sanitize user-controlled keys.
+ *
+ * @example
+ * unflattenObject({ "a.b.c": 1, d: 2 }); // { a: { b: { c: 1 } }, d: 2 }
+ */
+export declare const unflattenObject: (flat: Record<string, unknown>, separator?: string) => Record<string, unknown>;

package/module/es5/Object/unflattenObject.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unflattenObject = void 0;
+var _set = require("./set");
+/**
+ * Reconstructs a nested object from a flat path-keyed object.
+ *
+ * @param {Record<string, unknown>} flat - Flat input keyed by joined paths
+ * @param {string} [separator="."] - Separator used in path keys
+ * @returns {Record<string, unknown>} A nested object
+ *
+ * @remarks
+ * **Prototype pollution warning:** Internally uses `set`, which does not
+ * filter out prototype-polluting keys. Sanitize user-controlled keys.
+ *
+ * @example
+ * unflattenObject({ "a.b.c": 1, d: 2 }); // { a: { b: { c: 1 } }, d: 2 }
+ */
+var unflattenObject = exports.unflattenObject = function unflattenObject(flat) {
+  var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ".";
+  var result = {};
+  for (var _i = 0, _Object$keys = Object.keys(flat); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    (0, _set.set)(result, key.split(separator), flat[key]);
+  }
+  return result;
+};

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

@@ -0,0 +1,7 @@
+export * from "./randomBoolean";
+export * from "./randomChoice";
+export * from "./randomFloat";
+export * from "./randomInt";
+export * from "./randomUuid";
+export * from "./seededRandom";
+export * from "./weightedChoice";