umt 2.5.0 → 2.7.0

package/module/es5/String/formatString/defaultFormatters.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultFormatters = void 0;
+function _readOnlyError(r) { throw new TypeError('"' + r + '" is read-only'); }
+/**
+ * Built-in formatter functions for formatString.
+ *
+ * Each formatter takes a value and optional arguments, returning a formatted string.
+ * Formatters are used with syntax like {value:formatterName} or {value:formatterName(arg1,arg2)}.
+ *
+ * Available formatters:
+ * - upper: Convert to uppercase
+ * - lower: Convert to lowercase
+ * - currency: Format as currency with locale support
+ * - date: Format dates with locale and format options
+ * - time: Format time with locale support
+ * - number: Format numbers with precision control
+ * - plural: Choose singular/plural form based on count
+ * - pad: Pad string with characters to specified length
+ *
+ * @example
+ * // Usage in formatString
+ * formatString("{name:upper}", { name: "alice" }) // → "ALICE"
+ * formatString("{price:currency(ja-JP,JPY)}", { price: 1000 }) // → "￥1,000"
+ * formatString("{count:plural(item,items)}", { count: 1 }) // → "item"
+ */
+var defaultFormatters = exports.defaultFormatters = {
+  upper: function upper(value) {
+    return String(value).toUpperCase();
+  },
+  lower: function lower(value) {
+    return String(value).toLowerCase();
+  },
+  currency: function currency(value) {
+    var locale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "en-US";
+    var _currency = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "USD";
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: _currency
+    }).format(Number(value));
+  },
+  date: function date(value) {
+    var locale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "en-US";
+    var format = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "short";
+    var date = value instanceof Date ? value : new Date(String(value));
+    if (format === "iso") {
+      return date.toISOString();
+    }
+    if (format === "time") {
+      return date.toLocaleTimeString(locale);
+    }
+    return date.toLocaleDateString(locale);
+  },
+  time: function time(value) {
+    var locale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "en-US";
+    var date = value instanceof Date ? value : new Date(String(value));
+    return date.toLocaleTimeString(locale);
+  },
+  number: function number(value) {
+    var locale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "en-US";
+    var minimumFractionDigits = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "0";
+    var maximumFractionDigits = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "20";
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: Number(minimumFractionDigits),
+      maximumFractionDigits: Number(maximumFractionDigits)
+    }).format(Number(value));
+  },
+  plural: function plural(value, singular, _plural) {
+    return Number(value) === 1 ? singular : _plural;
+  },
+  pad: function pad(value) {
+    var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "2";
+    var _char = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "0";
+    return String(value).padStart(Number(length), _char);
+  }
+};

package/module/es5/String/formatString/detectMode.d.ts

@@ -0,0 +1,26 @@
+import type { FormatData } from "$/string/formatString/formatData";
+import type { FormatOptions } from "$/string/formatString/formatOptions";
+import type { FormatValue } from "$/string/formatString/formatValue";
+/**
+ * Detects whether formatString should use indexed or named mode based on arguments.
+ *
+ * Named mode: First argument is a non-array object
+ * Indexed mode: Arguments are treated as array values
+ *
+ * @param dataOrFirstValue - First argument (object for named mode, value for indexed mode)
+ * @param optionsOrSecondValue - Second argument (options for named mode, value for indexed mode)
+ * @param restValues - Remaining arguments for indexed mode
+ * @returns Object containing data and options for formatting
+ *
+ * @example
+ * // Named mode detection
+ * detectMode({ name: "Alice" }) // → { data: { name: "Alice" }, options: {} }
+ *
+ * @example
+ * // Indexed mode detection
+ * detectMode("first", "second") // → { data: ["first", "second"], options: {} }
+ */
+export declare function detectMode(dataOrFirstValue: FormatData | FormatValue | undefined, optionsOrSecondValue: FormatOptions | FormatValue | undefined, restValues: FormatValue[]): {
+    data: unknown;
+    options: FormatOptions;
+};

package/module/es5/String/formatString/detectMode.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectMode = detectMode;
+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 _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 _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 _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); }
+/**
+ * Detects whether formatString should use indexed or named mode based on arguments.
+ *
+ * Named mode: First argument is a non-array object
+ * Indexed mode: Arguments are treated as array values
+ *
+ * @param dataOrFirstValue - First argument (object for named mode, value for indexed mode)
+ * @param optionsOrSecondValue - Second argument (options for named mode, value for indexed mode)
+ * @param restValues - Remaining arguments for indexed mode
+ * @returns Object containing data and options for formatting
+ *
+ * @example
+ * // Named mode detection
+ * detectMode({ name: "Alice" }) // → { data: { name: "Alice" }, options: {} }
+ *
+ * @example
+ * // Indexed mode detection
+ * detectMode("first", "second") // → { data: ["first", "second"], options: {} }
+ */
+function detectMode(dataOrFirstValue, optionsOrSecondValue, restValues) {
+  var isFirstArgumentObject = dataOrFirstValue !== undefined && _typeof(dataOrFirstValue) === "object" && dataOrFirstValue !== null && !Array.isArray(dataOrFirstValue) && !(dataOrFirstValue instanceof Date);
+  var isSecondArgumentOptions = optionsOrSecondValue !== undefined && _typeof(optionsOrSecondValue) === "object" && optionsOrSecondValue !== null && !Array.isArray(optionsOrSecondValue) && !(optionsOrSecondValue instanceof Date) && "formatters" in optionsOrSecondValue;
+  if (isFirstArgumentObject && optionsOrSecondValue === undefined && restValues.length === 0) {
+    return {
+      data: dataOrFirstValue,
+      options: {}
+    };
+  }
+  if (isFirstArgumentObject && isSecondArgumentOptions && restValues.length === 0) {
+    return {
+      data: dataOrFirstValue,
+      options: optionsOrSecondValue
+    };
+  }
+  var allValues = [];
+  if (dataOrFirstValue !== undefined) {
+    allValues.push(dataOrFirstValue);
+  }
+  if (optionsOrSecondValue !== undefined) {
+    allValues.push(optionsOrSecondValue);
+  }
+  allValues.push.apply(allValues, _toConsumableArray(restValues));
+  return {
+    data: allValues,
+    options: {}
+  };
+}

package/module/es5/String/formatString/getValue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Retrieves a value from an object using a dot-notation path with array index support.
+ *
+ * Supports nested properties and array access with positive/negative indices.
+ *
+ * @param object - The object to retrieve the value from
+ * @param path - Dot-notation path (e.g., "user.name", "items[0]", "data[0].items[-1].name")
+ * @returns The value at the specified path, or undefined if not found
+ *
+ * @example
+ * // Simple property access
+ * getValue({ name: "Alice" }, "name") // → "Alice"
+ *
+ * @example
+ * // Nested property access
+ * getValue({ user: { name: "Bob" } }, "user.name") // → "Bob"
+ *
+ * @example
+ * // Array access
+ * getValue({ items: ["A", "B", "C"] }, "items[0]") // → "A"
+ * getValue({ items: ["A", "B", "C"] }, "items[-1]") // → "C"
+ *
+ * @example
+ * // Complex nested access
+ * getValue({ users: [{ name: "Alice" }] }, "users[0].name") // → "Alice"
+ */
+export declare function getValue(object: unknown, path: string): unknown;

package/module/es5/String/formatString/getValue.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getValue = getValue;
+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 _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 _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; }
+/**
+ * Retrieves a value from an object using a dot-notation path with array index support.
+ *
+ * Supports nested properties and array access with positive/negative indices.
+ *
+ * @param object - The object to retrieve the value from
+ * @param path - Dot-notation path (e.g., "user.name", "items[0]", "data[0].items[-1].name")
+ * @returns The value at the specified path, or undefined if not found
+ *
+ * @example
+ * // Simple property access
+ * getValue({ name: "Alice" }, "name") // → "Alice"
+ *
+ * @example
+ * // Nested property access
+ * getValue({ user: { name: "Bob" } }, "user.name") // → "Bob"
+ *
+ * @example
+ * // Array access
+ * getValue({ items: ["A", "B", "C"] }, "items[0]") // → "A"
+ * getValue({ items: ["A", "B", "C"] }, "items[-1]") // → "C"
+ *
+ * @example
+ * // Complex nested access
+ * getValue({ users: [{ name: "Alice" }] }, "users[0].name") // → "Alice"
+ */
+function getValue(object, path) {
+  var segments = [];
+  var parts = path.split(".");
+  var _iterator = _createForOfIteratorHelper(parts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      var arrayMatch = part.match(/^(.+?)\[(-?\d+)\]$/);
+      if (arrayMatch) {
+        var _arrayMatch = _slicedToArray(arrayMatch, 3),
+          key = _arrayMatch[1],
+          indexString = _arrayMatch[2];
+        segments.push({
+          key: key,
+          index: Number(indexString)
+        });
+      } else {
+        segments.push({
+          key: part
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var current = object;
+  for (var _i = 0, _segments = segments; _i < _segments.length; _i++) {
+    var segment = _segments[_i];
+    if (_typeof(current) !== "object" || current == null) {
+      return;
+    }
+    current = current[segment.key];
+    if (segment.index !== undefined) {
+      if (!Array.isArray(current)) {
+        return;
+      }
+      var index = segment.index;
+      current = index < 0 ? current[current.length + index] : current[index];
+    }
+  }
+  return current;
+}

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

@@ -0,0 +1,91 @@
+import type { FormatData } from "$/string/formatString/formatData";
+import type { FormatOptions } from "$/string/formatString/formatOptions";
+import type { FormatValue } from "$/string/formatString/formatValue";
+/**
+ * Replaces placeholders in a template string with specified values.
+ *
+ * Supports two modes:
+ * 1. **Indexed mode**: Use numbered placeholders like {0}, {1}, {2}...
+ * 2. **Named mode**: Use named placeholders with an object like {name}, {age}...
+ *
+ * ## Advanced Features
+ *
+ * ### Nested Object Access
+ * Access nested properties using dot notation: `{user.name}`, `{user.address.city}`
+ *
+ * ### Array Access
+ * Access array elements with brackets: `{items[0]}`, `{users[1].name}`
+ * Supports negative indices: `{items[-1]}` (last element), `{items[-2]}` (second to last)
+ *
+ * ### Default Values
+ * Provide fallback values using pipe syntax: `{name|Unknown}`, `{age|N/A}`
+ *
+ * ### Formatters
+ * Apply formatters to values: `{name:upper}`, `{price:currency}`, `{date:date}`
+ *
+ * Built-in formatters:
+ * - `upper` - Convert to uppercase
+ * - `lower` - Convert to lowercase
+ * - `currency(locale?, currency?)` - Format as currency (e.g., `{price:currency(ja-JP,JPY)}`)
+ * - `date(locale?, format?)` - Format dates (format: short|medium|long|full|iso|time)
+ * - `time(locale?)` - Format time
+ * - `number(locale?, minFraction?, maxFraction?)` - Format numbers
+ * - `plural(singular, plural)` - Pluralization (e.g., `{count:plural(item,items)}`)
+ * - `pad(length, char?)` - Pad string/number (e.g., `{id:pad(4,0)}`)
+ *
+ * ### Escape Sequences
+ * Use double braces to escape: `{{name}}` renders as literal `{name}`
+ *
+ * @param template - Template string containing placeholders
+ * @param data - Data object for named mode OR first value for indexed mode
+ * @param options - Options object with custom formatters (named mode only)
+ * @returns String with placeholders replaced with formatted values
+ *
+ * @example
+ * // Indexed mode - basic replacement
+ * formatString("Hello, {0}! It's {1} today.", "World", "sunny");
+ * // → "Hello, World! It's sunny today."
+ *
+ * @example
+ * // Named mode - object properties
+ * formatString("Hello, {name}! You are {age} years old.", { name: "Alice", age: 25 });
+ * // → "Hello, Alice! You are 25 years old."
+ *
+ * @example
+ * // Nested object access
+ * formatString("User: {user.name}, Email: {user.email}", {
+ *   user: { name: "Charlie", email: "charlie@example.com" }
+ * });
+ * // → "User: Charlie, Email: charlie@example.com"
+ *
+ * @example
+ * // Array access with negative indices
+ * formatString("First: {items[0]}, Last: {items[-1]}", { items: ["A", "B", "C"] });
+ * // → "First: A, Last: C"
+ *
+ * @example
+ * // Default values
+ * formatString("Name: {name|Unknown}, Age: {age|N/A}", { age: 25 });
+ * // → "Name: Unknown, Age: 25"
+ *
+ * @example
+ * // Built-in formatters
+ * formatString("Price: {price:currency(ja-JP,JPY)}", { price: 1234 });
+ * // → "Price: ￥1,234"
+ *
+ * @example
+ * // Custom formatters
+ * formatString("Reversed: {text:reverse}", { text: "hello" }, {
+ *   formatters: {
+ *     reverse: (value) => String(value).split("").reverse().join("")
+ *   }
+ * });
+ * // → "Reversed: olleh"
+ *
+ * @example
+ * // Escape sequences
+ * formatString("Literal {{name}} and value {name}", { name: "Alice" });
+ * // → "Literal {name} and value Alice"
+ */
+export declare function formatString(template: string, data?: FormatData, options?: FormatOptions): string;
+export declare function formatString(template: string, ...values: FormatValue[]): string;

package/module/es5/String/formatString/index.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatString = formatString;
+var _applyFormatter = require("./applyFormatter");
+var _defaultFormatters = require("./defaultFormatters");
+var _detectMode2 = require("./detectMode");
+var _getValue = require("./getValue");
+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 _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(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); }
+/**
+ * Replaces placeholders in a template string with specified values.
+ *
+ * Supports two modes:
+ * 1. **Indexed mode**: Use numbered placeholders like {0}, {1}, {2}...
+ * 2. **Named mode**: Use named placeholders with an object like {name}, {age}...
+ *
+ * ## Advanced Features
+ *
+ * ### Nested Object Access
+ * Access nested properties using dot notation: `{user.name}`, `{user.address.city}`
+ *
+ * ### Array Access
+ * Access array elements with brackets: `{items[0]}`, `{users[1].name}`
+ * Supports negative indices: `{items[-1]}` (last element), `{items[-2]}` (second to last)
+ *
+ * ### Default Values
+ * Provide fallback values using pipe syntax: `{name|Unknown}`, `{age|N/A}`
+ *
+ * ### Formatters
+ * Apply formatters to values: `{name:upper}`, `{price:currency}`, `{date:date}`
+ *
+ * Built-in formatters:
+ * - `upper` - Convert to uppercase
+ * - `lower` - Convert to lowercase
+ * - `currency(locale?, currency?)` - Format as currency (e.g., `{price:currency(ja-JP,JPY)}`)
+ * - `date(locale?, format?)` - Format dates (format: short|medium|long|full|iso|time)
+ * - `time(locale?)` - Format time
+ * - `number(locale?, minFraction?, maxFraction?)` - Format numbers
+ * - `plural(singular, plural)` - Pluralization (e.g., `{count:plural(item,items)}`)
+ * - `pad(length, char?)` - Pad string/number (e.g., `{id:pad(4,0)}`)
+ *
+ * ### Escape Sequences
+ * Use double braces to escape: `{{name}}` renders as literal `{name}`
+ *
+ * @param template - Template string containing placeholders
+ * @param data - Data object for named mode OR first value for indexed mode
+ * @param options - Options object with custom formatters (named mode only)
+ * @returns String with placeholders replaced with formatted values
+ *
+ * @example
+ * // Indexed mode - basic replacement
+ * formatString("Hello, {0}! It's {1} today.", "World", "sunny");
+ * // → "Hello, World! It's sunny today."
+ *
+ * @example
+ * // Named mode - object properties
+ * formatString("Hello, {name}! You are {age} years old.", { name: "Alice", age: 25 });
+ * // → "Hello, Alice! You are 25 years old."
+ *
+ * @example
+ * // Nested object access
+ * formatString("User: {user.name}, Email: {user.email}", {
+ *   user: { name: "Charlie", email: "charlie@example.com" }
+ * });
+ * // → "User: Charlie, Email: charlie@example.com"
+ *
+ * @example
+ * // Array access with negative indices
+ * formatString("First: {items[0]}, Last: {items[-1]}", { items: ["A", "B", "C"] });
+ * // → "First: A, Last: C"
+ *
+ * @example
+ * // Default values
+ * formatString("Name: {name|Unknown}, Age: {age|N/A}", { age: 25 });
+ * // → "Name: Unknown, Age: 25"
+ *
+ * @example
+ * // Built-in formatters
+ * formatString("Price: {price:currency(ja-JP,JPY)}", { price: 1234 });
+ * // → "Price: ￥1,234"
+ *
+ * @example
+ * // Custom formatters
+ * formatString("Reversed: {text:reverse}", { text: "hello" }, {
+ *   formatters: {
+ *     reverse: (value) => String(value).split("").reverse().join("")
+ *   }
+ * });
+ * // → "Reversed: olleh"
+ *
+ * @example
+ * // Escape sequences
+ * formatString("Literal {{name}} and value {name}", { name: "Alice" });
+ * // → "Literal {name} and value Alice"
+ */
+
+function formatString(template, dataOrFirstValue, optionsOrSecondValue) {
+  var escapedTemplate = template.replaceAll("{{", "\0").replaceAll("}}", "\x01");
+  for (var _len = arguments.length, restValues = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+    restValues[_key - 3] = arguments[_key];
+  }
+  var _detectMode = (0, _detectMode2.detectMode)(dataOrFirstValue, optionsOrSecondValue, restValues),
+    data = _detectMode.data,
+    options = _detectMode.options;
+  var formatters = _objectSpread(_objectSpread({}, _defaultFormatters.defaultFormatters), options.formatters);
+  var result = escapedTemplate.replaceAll(/{([^}]+)}/g, function (match, content) {
+    var _content$split$map = content.split("|").map(function (part) {
+        return part.trim();
+      }),
+      _content$split$map2 = _slicedToArray(_content$split$map, 2),
+      pathAndFormatter = _content$split$map2[0],
+      defaultValue = _content$split$map2[1];
+    var _pathAndFormatter$spl = pathAndFormatter.split(":"),
+      _pathAndFormatter$spl2 = _toArray(_pathAndFormatter$spl),
+      path = _pathAndFormatter$spl2[0],
+      formatterParts = _pathAndFormatter$spl2.slice(1);
+    var formatterString = formatterParts.join(":");
+    var value;
+    if (Array.isArray(data)) {
+      var index = Number(path);
+      value = Number.isNaN(index) ? undefined : data[index];
+    } else {
+      value = (0, _getValue.getValue)(data, path);
+    }
+    if (value === undefined || value === null) {
+      if (defaultValue === undefined) {
+        return match;
+      }
+      value = defaultValue;
+    }
+    if (formatterString) {
+      return (0, _applyFormatter.applyFormatter)(value, formatterString, formatters);
+    }
+    return String(value);
+  });
+  return result.replaceAll("\0", "{").replaceAll("\x01", "}");
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Perform fuzzy string matching on an array of strings
+ * @param query - The search query
+ * @param items - Array of strings to search in
+ * @param threshold - Similarity threshold (0-1) for matching (default: 0.6)
+ * @returns Array of matching items with their similarity scores, sorted by best match
+ * @example
+ * fuzzySearch("hello", ["hello", "world", "helo", "help"]);
+ * // [{ item: "hello", score: 1 }, { item: "helo", score: 0.8 }, { item: "help", score: 0.6 }]
+ */
+export declare const fuzzySearch: (query: string, items: string[], threshold?: number) => Array<{
+    item: string;
+    score: number;
+}>;

package/module/es5/String/fuzzySearch.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fuzzySearch = void 0;
+var _levenshteinDistance = require("./levenshteinDistance");
+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; }
+/**
+ * Perform fuzzy string matching on an array of strings
+ * @param query - The search query
+ * @param items - Array of strings to search in
+ * @param threshold - Similarity threshold (0-1) for matching (default: 0.6)
+ * @returns Array of matching items with their similarity scores, sorted by best match
+ * @example
+ * fuzzySearch("hello", ["hello", "world", "helo", "help"]);
+ * // [{ item: "hello", score: 1 }, { item: "helo", score: 0.8 }, { item: "help", score: 0.6 }]
+ */
+var fuzzySearch = exports.fuzzySearch = function fuzzySearch(query, items) {
+  var threshold = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.6;
+  if (query.length === 0) {
+    return [];
+  }
+  var results = [];
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var distance = (0, _levenshteinDistance.levenshteinDistance)(query.toLowerCase(), item.toLowerCase());
+      var maxLength = Math.max(query.length, item.length);
+      var score = 1 - distance / maxLength;
+      if (score >= threshold) {
+        results.push({
+          item: item,
+          score: score
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return results.sort(function (a, b) {
+    return b.score - a.score;
+  });
+};

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

@@ -1,14 +1,23 @@
+export * from "./camelCase";
 export * from "./deleteSpaces";
+export * from "./escapeHtml";
 export * from "./formatString";
 export * from "./fromBase64";
+export * from "./fuzzySearch";
 export * from "./hasNoLetters";
+export * from "./kebabCase";
+export * from "./levenshteinDistance";
 export * from "./padEnd";
 export * from "./padStart";
 export * from "./randomString";
 export * from "./randomStringInitialization";
 export * from "./reverseString";
+export * from "./slugify";
+export * from "./stringSimilarity";
 export * from "./toBase64";
 export * from "./toHalfWidth";
 export * from "./trimCharacters";
 export * from "./trimEndCharacters";
 export * from "./trimStartCharacters";
+export * from "./truncate";
+export * from "./unescapeHtml";