umt 2.16.0 → 2.17.0

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;

package/module/es5/String/dedent.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dedent = 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; }
+/**
+ * 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"
+ */
+var dedent = exports.dedent = function dedent(string_) {
+  var raw;
+  if (typeof string_ === "string") {
+    raw = string_;
+  } else {
+    var assembled = "";
+    var index = 0;
+    var _iterator = _createForOfIteratorHelper(string_),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var part = _step.value;
+        assembled += part;
+        if (index < (arguments.length <= 1 ? 0 : arguments.length - 1)) {
+          assembled += String(index + 1 < 1 || arguments.length <= index + 1 ? undefined : arguments[index + 1]);
+        }
+        index += 1;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    raw = assembled;
+  }
+  var lines = raw.split("\n");
+  var minIndent = Number.POSITIVE_INFINITY;
+  var _iterator2 = _createForOfIteratorHelper(lines),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var line = _step2.value;
+      if (line.trim().length === 0) {
+        continue;
+      }
+      var indent = 0;
+      while (indent < line.length && (line[indent] === " " || line[indent] === "\t")) {
+        indent += 1;
+      }
+      if (indent < minIndent) {
+        minIndent = indent;
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  if (!Number.isFinite(minIndent)) {
+    return raw;
+  }
+  return lines.map(function (line) {
+    return line.slice(minIndent);
+  }).join("\n");
+};

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

@@ -1,4 +1,7 @@
 export * from "./camelCase";
+export * from "./capitalize";
+export * from "./capitalizeWord";
+export * from "./dedent";
 export * from "./deleteSpaces";
 export * from "./escapeHtml";
 export * from "./formatString";
@@ -7,17 +10,24 @@ export * from "./fuzzySearch";
 export * from "./hasNoLetters";
 export * from "./kebabCase";
 export * from "./levenshteinDistance";
+export * from "./mask";
 export * from "./padEnd";
 export * from "./padStart";
+export * from "./pascalCase";
 export * from "./randomString";
 export * from "./randomStringInitialization";
 export * from "./reverseString";
 export * from "./slugify";
+export * from "./snakeCase";
 export * from "./stringSimilarity";
+export * from "./titleCase";
 export * from "./toBase64";
 export * from "./toHalfWidth";
 export * from "./trimCharacters";
 export * from "./trimEndCharacters";
 export * from "./trimStartCharacters";
 export * from "./truncate";
+export * from "./uncapitalize";
 export * from "./unescapeHtml";
+export * from "./wordCount";
+export * from "./words";