umt 2.5.0 → 2.6.0

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/index.d.ts

@@ -1,12 +1,17 @@
+export * from "./camelCase";
 export * from "./deleteSpaces";
+export * from "./escapeHtml";
 export * from "./formatString";
 export * from "./fromBase64";
 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 "./stringSimilarity";
 export * from "./toBase64";
 export * from "./toHalfWidth";
 export * from "./trimCharacters";

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;
@@ -47,6 +69,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 +146,17 @@ Object.keys(_reverseString).forEach(function (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;

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/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/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/isDouble.js

@@ -18,7 +18,7 @@ var isDouble = exports.isDouble = function isDouble(x) {
   var loose = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   if (loose) {
     return (
-      // biome-ignore lint/suspicious/noGlobalIsFinite: <explanation>
+      // biome-ignore lint/suspicious/noGlobalIsFinite: ignore
       isFinite(x) && !Number.isNaN(x) && Number.isFinite(Number(x)) && !Number.isInteger(Number(x))
     );
   }

package/module/es5/Validate/isNode.js

@@ -9,6 +9,7 @@ exports.isNode = void 0;
  */
 var isNode = exports.isNode = function isNode() {
   try {
+    // biome-ignore lint/nursery/noProcessGlobal: ignore
     return typeof process !== "undefined" && typeof require !== "undefined";
   } catch (_unused) {
     return false;

package/module/es5/Validate/isNumber.js

@@ -23,6 +23,6 @@ var isNumber = exports.isNumber = function isNumber(number) {
     return false;
   }
   return number !== null && typeof number !== "boolean" && loose ?
-  // biome-ignore lint/suspicious/noGlobalIsFinite: <explanation>
+  // biome-ignore lint/suspicious/noGlobalIsFinite: ignore
   isFinite(number) : Number.isFinite(number);
 };

package/module/es5/Validate/isValueNaN.js

@@ -17,6 +17,6 @@ exports.isValueNaN = void 0;
  */
 var isValueNaN = exports.isValueNaN = function isValueNaN(value) {
   var loose = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  // biome-ignore lint/suspicious/noGlobalIsNan: <explanation>
+  // biome-ignore lint/suspicious/noGlobalIsNan: ignore
   return loose ? isNaN(value) : Number.isNaN(value);
 };

package/module/es5/Validate/number/even.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.even = void 0;
+var _isDouble = require("@/Validate/isDouble");
 /**
  * Number validation module for even numbers
  * Provides validation functionality for checking if a number is even
@@ -19,6 +20,9 @@ var even = exports.even = function even(message) {
     type: "number",
     message: message,
     validate: function validate(value) {
+      if ((0, _isDouble.isDouble)(value, false)) {
+        return false;
+      }
       return value % 2 === 0;
     }
   };

package/module/es5/Validate/number/odd.js

@@ -4,11 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.odd = void 0;
+var _isDouble = require("@/Validate/isDouble");
 var odd = exports.odd = function odd(message) {
   return {
     type: "number",
     message: message,
     validate: function validate(value) {
+      if ((0, _isDouble.isDouble)(value, false)) {
+        return false;
+      }
       return value % 2 !== 0;
     }
   };

package/module/es5/Validate/string/email.js

@@ -4,6 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.email = void 0;
+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; }
 /**
  * String validation module for email addresses
  * Provides validation functionality for checking if a string is a valid email address
@@ -16,11 +22,30 @@ exports.email = void 0;
  */
 var email = exports.email = function email(message) {
   // Regular expression for email address validation
-  var emailRegex = /^[\+\x2D0-9A-Z_a-z\u017F\u212A]+(?:\.[\+\x2D0-9A-Z_a-z\u017F\u212A]+)*@[0-9a-z\u017F\u212A]+(?:[\x2D\.][0-9a-z\u017F\u212A]+)*\.[a-z\u017F\u212A]{2,}$/i;
+  var emailRegex = /^[a-zA-Z0-9]([a-zA-Z0-9._+-]*[a-zA-Z0-9])?@[a-zA-Z0-9]([a-zA-Z0-9.-]*[a-zA-Z0-9])?\.[a-zA-Z]{2,}$/;
   return {
     type: "string",
     message: message,
     validate: function validate(value) {
+      // Check for consecutive dots
+      if (value.includes("..")) {
+        return false;
+      }
+      // Check for leading/trailing dots in local part
+      var _value$split = value.split("@"),
+        _value$split2 = _slicedToArray(_value$split, 2),
+        localPart = _value$split2[0],
+        domainPart = _value$split2[1];
+      if (!(localPart && domainPart)) {
+        return false;
+      }
+      if (localPart.startsWith(".") || localPart.endsWith(".")) {
+        return false;
+      }
+      if (domainPart.startsWith(".") || domainPart.endsWith(".")) {
+        return false;
+      }
+      // Use regex for final validation
       return emailRegex.test(value);
     }
   };