umt 2.5.0 → 2.7.0

package/module/es5/String/index.js

@@ -3,6 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _camelCase = require("./camelCase");
+Object.keys(_camelCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _camelCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _camelCase[key];
+    }
+  });
+});
 var _deleteSpaces = require("./deleteSpaces");
 Object.keys(_deleteSpaces).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -14,6 +25,17 @@ Object.keys(_deleteSpaces).forEach(function (key) {
     }
   });
 });
+var _escapeHtml = require("./escapeHtml");
+Object.keys(_escapeHtml).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _escapeHtml[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _escapeHtml[key];
+    }
+  });
+});
 var _formatString = require("./formatString");
 Object.keys(_formatString).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -36,6 +58,17 @@ Object.keys(_fromBase).forEach(function (key) {
     }
   });
 });
+var _fuzzySearch = require("./fuzzySearch");
+Object.keys(_fuzzySearch).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fuzzySearch[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _fuzzySearch[key];
+    }
+  });
+});
 var _hasNoLetters = require("./hasNoLetters");
 Object.keys(_hasNoLetters).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -47,6 +80,28 @@ Object.keys(_hasNoLetters).forEach(function (key) {
     }
   });
 });
+var _kebabCase = require("./kebabCase");
+Object.keys(_kebabCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _kebabCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _kebabCase[key];
+    }
+  });
+});
+var _levenshteinDistance = require("./levenshteinDistance");
+Object.keys(_levenshteinDistance).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _levenshteinDistance[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _levenshteinDistance[key];
+    }
+  });
+});
 var _padEnd = require("./padEnd");
 Object.keys(_padEnd).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -102,6 +157,28 @@ Object.keys(_reverseString).forEach(function (key) {
     }
   });
 });
+var _slugify = require("./slugify");
+Object.keys(_slugify).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _slugify[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _slugify[key];
+    }
+  });
+});
+var _stringSimilarity = require("./stringSimilarity");
+Object.keys(_stringSimilarity).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _stringSimilarity[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _stringSimilarity[key];
+    }
+  });
+});
 var _toBase = require("./toBase64");
 Object.keys(_toBase).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -156,4 +233,26 @@ Object.keys(_trimStartCharacters).forEach(function (key) {
       return _trimStartCharacters[key];
     }
   });
+});
+var _truncate = require("./truncate");
+Object.keys(_truncate).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _truncate[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _truncate[key];
+    }
+  });
+});
+var _unescapeHtml = require("./unescapeHtml");
+Object.keys(_unescapeHtml).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _unescapeHtml[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _unescapeHtml[key];
+    }
+  });
 });

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

@@ -0,0 +1,6 @@
+/**
+ * Converts a string to kebab-case
+ * @param str - The string to convert
+ * @returns The kebab-case string
+ */
+export declare const kebabCase: (string_: string) => string;

package/module/es5/String/kebabCase.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kebabCase = void 0;
+/**
+ * Converts a string to kebab-case
+ * @param str - The string to convert
+ * @returns The kebab-case string
+ */
+var kebabCase = exports.kebabCase = function kebabCase(string_) {
+  return string_
+  // Insert dash between lowercase and uppercase
+  .replaceAll(/([a-z])([A-Z])/g, "$1-$2")
+  // Insert dash between sequences of uppercase letters and following lowercase
+  .replaceAll(/([A-Z])([A-Z][a-z])/g, "$1-$2")
+  // Replace spaces and underscores with dashes
+  .replaceAll(/[\s_]+/g, "-")
+  // Remove special characters except alphanumeric and dashes
+  .replaceAll(/[^a-zA-Z0-9-]/g, "-")
+  // Remove multiple consecutive dashes
+  .replaceAll(/-+/g, "-")
+  // Remove leading and trailing dashes
+  .replaceAll(/^-|-$/g, "").toLowerCase();
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Calculates the Levenshtein distance between two strings
+ * Returns the minimum number of single-character edits (insertions, deletions, or substitutions)
+ * @param str1 - First string to compare
+ * @param str2 - Second string to compare
+ * @returns The Levenshtein distance
+ */
+export declare const levenshteinDistance: (string1: string, string2: string) => number;

package/module/es5/String/levenshteinDistance.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.levenshteinDistance = void 0;
+/**
+ * Calculates the Levenshtein distance between two strings
+ * Returns the minimum number of single-character edits (insertions, deletions, or substitutions)
+ * @param str1 - First string to compare
+ * @param str2 - Second string to compare
+ * @returns The Levenshtein distance
+ */
+var levenshteinDistance = exports.levenshteinDistance = function levenshteinDistance(string1, string2) {
+  var length1 = string1.length;
+  var length2 = string2.length;
+
+  // Return the length of the other string if one is empty
+  if (length1 === 0) {
+    return length2;
+  }
+  if (length2 === 0) {
+    return length1;
+  }
+
+  // Create a 2D array for dynamic programming
+  var matrix = Array.from({
+    length: length1 + 1
+  }, function () {
+    return Array.from({
+      length: length2 + 1
+    }, function () {
+      return 0;
+    });
+  });
+
+  // Initialize first column and row
+  for (var index = 0; index <= length1; index++) {
+    matrix[index][0] = index;
+  }
+  for (var _index = 0; _index <= length2; _index++) {
+    matrix[0][_index] = _index;
+  }
+
+  // Calculate distances
+  for (var _index2 = 1; _index2 <= length1; _index2++) {
+    for (var index_ = 1; index_ <= length2; index_++) {
+      var cost = string1[_index2 - 1] === string2[index_ - 1] ? 0 : 1;
+      matrix[_index2][index_] = Math.min(matrix[_index2 - 1][index_] + 1,
+      // deletion
+      matrix[_index2][index_ - 1] + 1,
+      // insertion
+      matrix[_index2 - 1][index_ - 1] + cost // substitution
+      );
+    }
+  }
+  return matrix[length1][length2];
+};

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

@@ -0,0 +1,10 @@
+/**
+ * Convert a string to a URL-friendly slug
+ * @param str - The string to convert
+ * @returns The slugified string
+ * @example
+ * slugify("Hello World!"); // "hello-world"
+ * slugify("This is a Test"); // "this-is-a-test"
+ * slugify("Japanese: こんにちは"); // "japanese"
+ */
+export declare const slugify: (string_: string) => string;

package/module/es5/String/slugify.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.slugify = void 0;
+/**
+ * Convert a string to a URL-friendly slug
+ * @param str - The string to convert
+ * @returns The slugified string
+ * @example
+ * slugify("Hello World!"); // "hello-world"
+ * slugify("This is a Test"); // "this-is-a-test"
+ * slugify("Japanese: こんにちは"); // "japanese"
+ */
+var slugify = exports.slugify = function slugify(string_) {
+  return string_.normalize("NFD").replaceAll(/[\u0300-\u036F]/g, "").toLowerCase().replaceAll(/[^\w\s-]/g, "-").replaceAll(/\s+/g, "-").replaceAll(/_+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-+|-+$/g, "");
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Calculates the similarity between two strings as a percentage
+ * Uses Levenshtein distance normalized by the length of the longer string
+ * @param str1 - First string to compare
+ * @param str2 - Second string to compare
+ * @returns Similarity score between 0 (completely different) and 1 (identical)
+ */
+export declare const stringSimilarity: (string1: string, string2: string) => number;

package/module/es5/String/stringSimilarity.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringSimilarity = void 0;
+var _levenshteinDistance = require("./levenshteinDistance");
+/**
+ * Calculates the similarity between two strings as a percentage
+ * Uses Levenshtein distance normalized by the length of the longer string
+ * @param str1 - First string to compare
+ * @param str2 - Second string to compare
+ * @returns Similarity score between 0 (completely different) and 1 (identical)
+ */
+var stringSimilarity = exports.stringSimilarity = function stringSimilarity(string1, string2) {
+  // Identical strings have 100% similarity
+  if (string1 === string2) {
+    return 1;
+  }
+
+  // Empty strings handling
+  if (string1.length === 0 || string2.length === 0) {
+    return 0;
+  }
+  var distance = (0, _levenshteinDistance.levenshteinDistance)(string1, string2);
+  var maxLength = Math.max(string1.length, string2.length);
+
+  // Calculate similarity as 1 - (distance / maxLength)
+  return 1 - distance / maxLength;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Truncate a string to a specified length
+ * @param str - The string to truncate
+ * @param length - The maximum length
+ * @param suffix - The suffix to add when truncating (default: "...")
+ * @returns The truncated string
+ * @example
+ * truncate("Hello World", 5); // "Hello..."
+ * truncate("Hello World", 5, "~"); // "Hello~"
+ * truncate("Hello", 10); // "Hello"
+ */
+export declare const truncate: (string_: string, length: number, suffix?: string) => string;

package/module/es5/String/truncate.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.truncate = void 0;
+/**
+ * Truncate a string to a specified length
+ * @param str - The string to truncate
+ * @param length - The maximum length
+ * @param suffix - The suffix to add when truncating (default: "...")
+ * @returns The truncated string
+ * @example
+ * truncate("Hello World", 5); // "Hello..."
+ * truncate("Hello World", 5, "~"); // "Hello~"
+ * truncate("Hello", 10); // "Hello"
+ */
+var truncate = exports.truncate = function truncate(string_, length) {
+  var suffix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "...";
+  if (length < 0) {
+    throw new Error("Length must be non-negative");
+  }
+  if (string_.length <= length) {
+    return string_;
+  }
+  return string_.slice(0, length) + suffix;
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Unescapes HTML entities in a string
+ * @param string_ - The string to unescape
+ * @returns The unescaped string with HTML entities converted back to their original characters
+ * @example
+ * ```typescript
+ * unescapeHtml("<script>alert("Hello");</script>");
+ * // Returns: "<script>alert("Hello");</script>"
+ *
+ * unescapeHtml("Tom &amp; Jerry");
+ * // Returns: "Tom & Jerry"
+ *
+ * unescapeHtml("5 &lt; 10 &amp;&amp; 10 &gt; 5");
+ * // Returns: "5 < 10 && 10 > 5"
+ * ```
+ */
+export declare const unescapeHtml: (string_: string) => string;

package/module/es5/String/unescapeHtml.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unescapeHtml = void 0;
+/**
+ * HTML entities map for unescaping
+ */
+var htmlUnescapeMap = {
+  "&": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#x2F;": "/",
+  "&#x60;": "`",
+  "&#x3D;": "="
+};
+
+/**
+ * Unescapes HTML entities in a string
+ * @param string_ - The string to unescape
+ * @returns The unescaped string with HTML entities converted back to their original characters
+ * @example
+ * ```typescript
+ * unescapeHtml("&lt;script&gt;alert(&quot;Hello&quot;);&lt;/script&gt;");
+ * // Returns: "<script>alert("Hello");</script>"
+ *
+ * unescapeHtml("Tom &amp; Jerry");
+ * // Returns: "Tom & Jerry"
+ *
+ * unescapeHtml("5 &lt; 10 &amp;&amp; 10 &gt; 5");
+ * // Returns: "5 < 10 && 10 > 5"
+ * ```
+ */
+var unescapeHtml = exports.unescapeHtml = function unescapeHtml(string_) {
+  var entityRegex = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D);|&#(\d*);|&#x([0-9a-fA-F]*);/g;
+  return string_.replaceAll(entityRegex, function (match, dec, hex) {
+    if (dec !== undefined) {
+      var codePoint = Number.parseInt(dec, 10);
+      return Number.isNaN(codePoint) ? match : String.fromCodePoint(codePoint);
+    }
+    if (hex !== undefined) {
+      var _codePoint = Number.parseInt(hex, 16);
+      return Number.isNaN(_codePoint) ? match : String.fromCodePoint(_codePoint);
+    }
+    return htmlUnescapeMap[match];
+  });
+};

package/module/es5/Validate/core/index.js

@@ -24,7 +24,6 @@ var core = exports.core = function core(type) {
   return function (value) {
     var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var message = arguments.length > 2 ? arguments[2] : undefined;
-    // biome-ignore lint/suspicious/useValidTypeof: Type parameter is a string literal type from Types<T>
     if (_typeof(value) !== type) {
       return {
         validate: false,

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

@@ -3,6 +3,7 @@ export * from "./boolean";
 export * from "./number";
 export * from "./object";
 export * from "./string";
+export * from "./isDeepEqual";
 export * from "./isArray";
 export * from "./isBrowser";
 export * from "./isBun";

package/module/es5/Validate/index.js

@@ -58,6 +58,17 @@ Object.keys(_string).forEach(function (key) {
     }
   });
 });
+var _isDeepEqual = require("./isDeepEqual");
+Object.keys(_isDeepEqual).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isDeepEqual[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _isDeepEqual[key];
+    }
+  });
+});
 var _isArray = require("./isArray");
 Object.keys(_isArray).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/isDeepEqual.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Options for isDeepEqual comparison
+ */
+export interface IsDeepEqualOptions {
+    /**
+     * Whether to ignore array order when comparing arrays
+     * @default true
+     */
+    strictOrder?: boolean;
+}
+/**
+ * Performs a deep equality comparison between two values
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @param options - Comparison options
+ * @returns true if values are deeply equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isDeepEqual({ a: 1, b: [2, 3] }, { b: [2, 3], a: 1 }); // true
+ * isDeepEqual([1, 2, 3], [3, 2, 1]); // false
+ * isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false }); // true
+ * isDeepEqual(new Set([1, 2]), new Set([2, 1])); // true
+ * isDeepEqual(new Map([['a', 1]]), new Map([['a', 1]])); // true
+ * ```
+ */
+export declare function isDeepEqual(a: unknown, b: unknown, options?: IsDeepEqualOptions): boolean;