umt 2.16.0 → 2.18.0

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";

package/module/es5/Random/index.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _randomBoolean = require("./randomBoolean");
+Object.keys(_randomBoolean).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _randomBoolean[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _randomBoolean[key];
+    }
+  });
+});
+var _randomChoice = require("./randomChoice");
+Object.keys(_randomChoice).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _randomChoice[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _randomChoice[key];
+    }
+  });
+});
+var _randomFloat = require("./randomFloat");
+Object.keys(_randomFloat).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _randomFloat[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _randomFloat[key];
+    }
+  });
+});
+var _randomInt = require("./randomInt");
+Object.keys(_randomInt).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _randomInt[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _randomInt[key];
+    }
+  });
+});
+var _randomUuid = require("./randomUuid");
+Object.keys(_randomUuid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _randomUuid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _randomUuid[key];
+    }
+  });
+});
+var _seededRandom = require("./seededRandom");
+Object.keys(_seededRandom).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _seededRandom[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _seededRandom[key];
+    }
+  });
+});
+var _weightedChoice = require("./weightedChoice");
+Object.keys(_weightedChoice).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _weightedChoice[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _weightedChoice[key];
+    }
+  });
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Returns a random boolean. The probability of `true` defaults to 0.5.
+ * @param {number} [probability=0.5] - Probability of returning true (0..1)
+ * @returns {boolean} Random boolean
+ * @example
+ * randomBoolean(); // true or false equally
+ * randomBoolean(0.9); // true ~90% of the time
+ */
+export declare const randomBoolean: (probability?: number) => boolean;

package/module/es5/Random/randomBoolean.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomBoolean = void 0;
+/**
+ * Returns a random boolean. The probability of `true` defaults to 0.5.
+ * @param {number} [probability=0.5] - Probability of returning true (0..1)
+ * @returns {boolean} Random boolean
+ * @example
+ * randomBoolean(); // true or false equally
+ * randomBoolean(0.9); // true ~90% of the time
+ */
+var randomBoolean = exports.randomBoolean = function randomBoolean() {
+  var probability = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.5;
+  return Math.random() < probability;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Returns a uniformly random element from the input array.
+ * @template T - Element type
+ * @param {readonly T[]} items - Source array (must be non-empty)
+ * @returns {T} A randomly selected element
+ * @example
+ * randomChoice(["a", "b", "c"]);
+ */
+export declare const randomChoice: <T>(items: readonly T[]) => T;

package/module/es5/Random/randomChoice.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomChoice = void 0;
+/**
+ * Returns a uniformly random element from the input array.
+ * @template T - Element type
+ * @param {readonly T[]} items - Source array (must be non-empty)
+ * @returns {T} A randomly selected element
+ * @example
+ * randomChoice(["a", "b", "c"]);
+ */
+var randomChoice = exports.randomChoice = function randomChoice(items) {
+  var index = Math.floor(Math.random() * items.length);
+  return items[index];
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Returns a random float in the half-open interval `[min, max)`.
+ * @param {number} min - Inclusive lower bound
+ * @param {number} max - Exclusive upper bound
+ * @returns {number} Random float
+ * @example
+ * randomFloat(0, 1); // 0.000... up to but not including 1
+ */
+export declare const randomFloat: (min: number, max: number) => number;

package/module/es5/Random/randomFloat.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomFloat = void 0;
+/**
+ * Returns a random float in the half-open interval `[min, max)`.
+ * @param {number} min - Inclusive lower bound
+ * @param {number} max - Exclusive upper bound
+ * @returns {number} Random float
+ * @example
+ * randomFloat(0, 1); // 0.000... up to but not including 1
+ */
+var randomFloat = exports.randomFloat = function randomFloat(min, max) {
+  return Math.random() * (max - min) + min;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Returns a random integer in the closed interval `[min, max]`.
+ * @param {number} min - Inclusive lower bound
+ * @param {number} max - Inclusive upper bound
+ * @returns {number} Random integer
+ * @example
+ * randomInt(1, 6); // 1, 2, 3, 4, 5, or 6
+ */
+export declare const randomInt: (min: number, max: number) => number;

package/module/es5/Random/randomInt.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomInt = void 0;
+/**
+ * Returns a random integer in the closed interval `[min, max]`.
+ * @param {number} min - Inclusive lower bound
+ * @param {number} max - Inclusive upper bound
+ * @returns {number} Random integer
+ * @example
+ * randomInt(1, 6); // 1, 2, 3, 4, 5, or 6
+ */
+var randomInt = exports.randomInt = function randomInt(min, max) {
+  var lo = Math.ceil(min);
+  var hi = Math.floor(max);
+  return Math.floor(Math.random() * (hi - lo + 1)) + lo;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Generates a UUID v4 string. Uses `crypto.randomUUID` when available,
+ * otherwise falls back to `crypto.getRandomValues`.
+ *
+ * @returns {string} A UUID v4 in canonical 8-4-4-4-12 hex form
+ * @example
+ * randomUUID(); // e.g. "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed"
+ */
+export declare const randomUUID: () => string;

package/module/es5/Random/randomUuid.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomUUID = void 0;
+var DIGITS = "0123456789abcdef";
+var bytesToUuid = function bytesToUuid(bytes) {
+  var result = "";
+  for (var index = 0; index < 16; index += 1) {
+    if (index === 4 || index === 6 || index === 8 || index === 10) {
+      result += "-";
+    }
+    var _byte = bytes[index];
+    result += DIGITS[_byte >>> 4] + DIGITS[_byte & 0xf];
+  }
+  return result;
+};
+
+/**
+ * Generates a UUID v4 string. Uses `crypto.randomUUID` when available,
+ * otherwise falls back to `crypto.getRandomValues`.
+ *
+ * @returns {string} A UUID v4 in canonical 8-4-4-4-12 hex form
+ * @example
+ * randomUUID(); // e.g. "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed"
+ */
+var randomUUID = exports.randomUUID = function randomUUID() {
+  var _globalThis$crypto;
+  if (typeof ((_globalThis$crypto = globalThis.crypto) === null || _globalThis$crypto === void 0 ? void 0 : _globalThis$crypto.randomUUID) === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  var bytes = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(bytes);
+  bytes[6] = bytes[6] & 0x0f | 0x40;
+  bytes[8] = bytes[8] & 0x3f | 0x80;
+  return bytesToUuid(bytes);
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Returns a deterministic PRNG seeded from a number or string. Each call
+ * produces a float in `[0, 1)` from the same xoshiro256** stream.
+ *
+ * @param {number | string} seed - Seed value
+ * @returns {() => number} A function that returns sequential pseudo-random floats
+ * @example
+ * const rand = seededRandom("hello");
+ * rand(); // deterministic for the same seed
+ */
+export declare const seededRandom: (seed: number | string) => (() => number);

package/module/es5/Random/seededRandom.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.seededRandom = void 0;
+var _xoshiro = require("../Math/xoshiro256");
+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; }
+var TEXT_ENCODER = new TextEncoder();
+var hashStringToSeed = function hashStringToSeed(input) {
+  var hash = 2166136261;
+  var _iterator = _createForOfIteratorHelper(TEXT_ENCODER.encode(input)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _byte = _step.value;
+      hash ^= _byte;
+      hash = Math.imul(hash, 16777619);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return hash >>> 0;
+};
+
+/**
+ * Returns a deterministic PRNG seeded from a number or string. Each call
+ * produces a float in `[0, 1)` from the same xoshiro256** stream.
+ *
+ * @param {number | string} seed - Seed value
+ * @returns {() => number} A function that returns sequential pseudo-random floats
+ * @example
+ * const rand = seededRandom("hello");
+ * rand(); // deterministic for the same seed
+ */
+var seededRandom = exports.seededRandom = function seededRandom(seed) {
+  var initial = typeof seed === "number" ? seed >>> 0 : hashStringToSeed(seed);
+  var state = [initial || 1, Math.imul(initial, 0x9e3779b9) >>> 0 || 2, Math.imul(initial, 0x85ebca6b) >>> 0 || 3, Math.imul(initial, 0xc2b2ae35) >>> 0 || 4];
+  return function () {
+    return (0, _xoshiro.xoshiro256)(state);
+  };
+};

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

@@ -0,0 +1,15 @@
+export interface WeightedItem<T> {
+    value: T;
+    weight: number;
+}
+/**
+ * Returns a random element using cumulative weights and binary search.
+ * Items with non-positive weights are skipped from the pool.
+ *
+ * @template T - Element type
+ * @param {readonly WeightedItem<T>[]} items - Items with non-negative weights
+ * @returns {T} A randomly selected element
+ * @example
+ * weightedChoice([{ value: "a", weight: 1 }, { value: "b", weight: 4 }]);
+ */
+export declare const weightedChoice: <T>(items: readonly WeightedItem<T>[]) => T;

package/module/es5/Random/weightedChoice.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.weightedChoice = void 0;
+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; }
+/**
+ * Returns a random element using cumulative weights and binary search.
+ * Items with non-positive weights are skipped from the pool.
+ *
+ * @template T - Element type
+ * @param {readonly WeightedItem<T>[]} items - Items with non-negative weights
+ * @returns {T} A randomly selected element
+ * @example
+ * weightedChoice([{ value: "a", weight: 1 }, { value: "b", weight: 4 }]);
+ */
+var weightedChoice = exports.weightedChoice = function weightedChoice(items) {
+  var cumulative = [];
+  var total = 0;
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      if (item.weight > 0) {
+        total += item.weight;
+      }
+      cumulative.push(total);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var target = Math.random() * total;
+  var lo = 0;
+  var hi = cumulative.length - 1;
+  while (lo < hi) {
+    var mid = lo + hi >>> 1;
+    if (cumulative[mid] <= target) {
+      lo = mid + 1;
+    } else {
+      hi = mid;
+    }
+  }
+  return items[lo].value;
+};

package/module/es5/String/capitalize.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Capitalizes the first grapheme of a string. Surrogate-pair safe.
+ * Does not lowercase the rest of the string.
+ *
+ * @param {string} string_ - Input string
+ * @returns {string} String with the first grapheme uppercased
+ * @example
+ * capitalize("hello"); // "Hello"
+ * capitalize("éclair"); // "Éclair"
+ * capitalize(""); // ""
+ */
+export declare const capitalize: (string_: string) => string;

package/module/es5/String/capitalize.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.capitalize = void 0;
+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; }
+/**
+ * Capitalizes the first grapheme of a string. Surrogate-pair safe.
+ * Does not lowercase the rest of the string.
+ *
+ * @param {string} string_ - Input string
+ * @returns {string} String with the first grapheme uppercased
+ * @example
+ * capitalize("hello"); // "Hello"
+ * capitalize("éclair"); // "Éclair"
+ * capitalize(""); // ""
+ */
+var capitalize = exports.capitalize = function capitalize(string_) {
+  var _iterator = _createForOfIteratorHelper(string_),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var first = _step.value;
+      return first.toUpperCase() + string_.slice(first.length);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return string_;
+};

package/module/es5/String/capitalizeWord.d.ts

@@ -0,0 +1 @@
+export declare const capitalizeWord: (word: string) => string;

package/module/es5/String/capitalizeWord.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.capitalizeWord = void 0;
+var capitalizeWord = exports.capitalizeWord = function capitalizeWord(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+};

package/module/es5/String/dedent.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Removes the minimum common leading whitespace from each line of the input.
+ * Works as a plain function or as a tagged template literal.
+ *
+ * @param {string | TemplateStringsArray} string_ - Input string or template strings array
+ * @param {...unknown[]} values - Interpolated values when used as a tag
+ * @returns {string} Dedented string
+ * @example
+ * dedent(`
+ *   line1
+ *     line2
+ * `); // "\nline1\n  line2\n"
+ *
+ * @example
+ * dedent`
+ *   value: ${1}
+ * `; // "\nvalue: 1\n"
+ */
+export declare const dedent: (string_: string | TemplateStringsArray, ...values: unknown[]) => string;