umt 2.14.0 → 2.16.0

package/module/es5/String/unescapeHtml.js

@@ -19,6 +19,34 @@ var htmlUnescapeMap = {
   "=": "="
 };
 
+/**
+ * Security: Checks whether a numeric code point is safe to decode.
+ * Rejects NULL (0), C0 control chars (1-31 except TAB 9, LF 10, CR 13),
+ * DEL (127), C1 control chars (128-159), lone surrogates (0xD800-0xDFFF),
+ * and values beyond the Unicode maximum (>0x10FFFF).
+ */
+var isSafeCodePoint = function isSafeCodePoint(codePoint) {
+  if (codePoint > 0x10ffff) {
+    return false;
+  }
+  if (codePoint === 0) {
+    return false;
+  }
+  if (codePoint >= 0xd800 && codePoint <= 0xdfff) {
+    return false;
+  }
+  if (codePoint <= 0x1f && codePoint !== 0x09 && codePoint !== 0x0a && codePoint !== 0x0d) {
+    return false;
+  }
+  if (codePoint === 0x7f) {
+    return false;
+  }
+  if (codePoint >= 0x80 && codePoint <= 0x9f) {
+    return false;
+  }
+  return true;
+};
+
 /**
  * Unescapes HTML entities in a string
  * @param string_ - The string to unescape
@@ -26,7 +54,7 @@ var htmlUnescapeMap = {
  * @example
  * ```typescript
  * unescapeHtml("&lt;script&gt;alert(&quot;Hello&quot;);&lt;/script&gt;");
- * // Returns: "<script>alert("Hello");</script>"
+ * // Returns: "<script>alert(\"Hello\");</script>"
  *
  * unescapeHtml("Tom &amp; Jerry");
  * // Returns: "Tom & Jerry"
@@ -36,15 +64,29 @@ var htmlUnescapeMap = {
  * ```
  */
 var unescapeHtml = exports.unescapeHtml = function unescapeHtml(string_) {
-  var entityRegex = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D);|&#(\d*);|&#x([\dA-Fa-f]*);/g;
+  var entityRegex = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D);|&#(\d{1,7});|&#x([\dA-Fa-f]{1,6});/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);
+      // Security: reject dangerous code points to prevent injection attacks.
+      // NULL bytes (0) enable null-byte injection that can truncate strings in
+      // downstream systems. C0 control chars (1-31 except TAB/LF/CR) and the
+      // DEL char (127) can break parsers. C1 control chars (128-159) are
+      // invalid in HTML. Surrogate code points (0xD800-0xDFFF) produce
+      // malformed strings. Out-of-range values (>0x10FFFF) are not valid
+      // Unicode. Leave these entity references unmodified rather than decoding
+      // them into potentially dangerous characters.
+      if (!isSafeCodePoint(codePoint)) {
+        return match;
+      }
+      return String.fromCodePoint(codePoint);
     }
     if (hex !== undefined) {
       var _codePoint = Number.parseInt(hex, 16);
-      return Number.isNaN(_codePoint) ? match : String.fromCodePoint(_codePoint);
+      if (!isSafeCodePoint(_codePoint)) {
+        return match;
+      }
+      return String.fromCodePoint(_codePoint);
     }
     return htmlUnescapeMap[match];
   });

package/module/es5/Tool/parseJson.js

@@ -4,6 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseJson = void 0;
+// Security: Keys that must be stripped during JSON parsing to prevent
+// prototype pollution. If an attacker controls the JSON input, they can
+// embed keys like "__proto__" which, when the parsed object is later
+// spread or merged (e.g. via Object.assign, spread operator, or any
+// deep-merge utility), can overwrite properties on Object.prototype
+// and affect all objects in the runtime.
+var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
 /**
  * Parses a JSON string into a typed JavaScript value
  * @template T The expected type of the parsed value (defaults to unknown)
@@ -12,5 +20,10 @@ exports.parseJson = void 0;
  * @throws {SyntaxError} If the JSON string is invalid
  */
 var parseJson = exports.parseJson = function parseJson(json) {
-  return JSON.parse(json);
+  return JSON.parse(json, function (key, value) {
+    if (DANGEROUS_KEYS.has(key)) {
+      return;
+    }
+    return value;
+  });
 };

package/module/es5/URL/buildUrl.js

@@ -25,6 +25,10 @@ var buildUrl = exports.buildUrl = function buildUrl(base) {
   var url = new URL(base);
   for (var _i = 0, _Object$keys = Object.keys(parameters); _i < _Object$keys.length; _i++) {
     var key = _Object$keys[_i];
+    // Prevent prototype pollution by rejecting dangerous keys
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
     url.searchParams.append(key, parameters[key]);
   }
   return url.toString();

package/module/es5/URL/parseQueryString.js

@@ -46,6 +46,10 @@ var parseQueryString = exports.parseQueryString = function parseQueryString(quer
       var _step$value = _slicedToArray(_step.value, 2),
         key = _step$value[0],
         value = _step$value[1];
+      // Prevent prototype pollution by rejecting dangerous keys
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        continue;
+      }
       result[key] = value;
     }
   } catch (err) {

package/module/es5/Validate/isDeepEqual.js

@@ -4,10 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.isDeepEqual = isDeepEqual;
-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 _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 _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; } }
@@ -93,19 +89,32 @@ function isDeepEqual(a, b) {
           _iterator.f();
         }
       } else {
-        var yCopy = _toConsumableArray(y);
+        // Performance: Use Set<number> to track matched indices instead of
+        // splice(), avoiding O(n) array shifts per removal (O(n²) → O(n)).
+        var usedIndices = new Set();
         var _iterator2 = _createForOfIteratorHelper(x),
           _step2;
         try {
           for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
             var itemX = _step2.value;
             var found = false;
-            for (var _index = 0; _index < yCopy.length; _index++) {
-              if (compare(itemX, yCopy[_index])) {
-                yCopy.splice(_index, 1);
-                found = true;
-                break;
+            var _iterator3 = _createForOfIteratorHelper(y.entries()),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _step3$value = _slicedToArray(_step3.value, 2),
+                  _index = _step3$value[0],
+                  itemY = _step3$value[1];
+                if (!usedIndices.has(_index) && compare(itemX, itemY)) {
+                  usedIndices.add(_index);
+                  found = true;
+                  break;
+                }
               }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
             }
             if (!found) {
               return false;
@@ -116,7 +125,7 @@ function isDeepEqual(a, b) {
         } finally {
           _iterator2.f();
         }
-        return yCopy.length === 0;
+        return usedIndices.size === y.length;
       }
       return true;
     }
@@ -124,35 +133,35 @@ function isDeepEqual(a, b) {
       if (x.size !== y.size) {
         return false;
       }
-      var _iterator3 = _createForOfIteratorHelper(x),
-        _step3;
+      var _iterator4 = _createForOfIteratorHelper(x),
+        _step4;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var item = _step3.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var item = _step4.value;
           var _found = false;
-          var _iterator4 = _createForOfIteratorHelper(y),
-            _step4;
+          var _iterator5 = _createForOfIteratorHelper(y),
+            _step5;
           try {
-            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-              var otherItem = _step4.value;
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var otherItem = _step5.value;
               if (compare(item, otherItem)) {
                 _found = true;
                 break;
               }
             }
           } catch (err) {
-            _iterator4.e(err);
+            _iterator5.e(err);
           } finally {
-            _iterator4.f();
+            _iterator5.f();
           }
           if (!_found) {
             return false;
           }
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator3.f();
+        _iterator4.f();
       }
       return true;
     }
@@ -160,39 +169,39 @@ function isDeepEqual(a, b) {
       if (x.size !== y.size) {
         return false;
       }
-      var _iterator5 = _createForOfIteratorHelper(x),
-        _step5;
+      var _iterator6 = _createForOfIteratorHelper(x),
+        _step6;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var _step5$value = _slicedToArray(_step5.value, 2),
-            key = _step5$value[0],
-            value = _step5$value[1];
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _step6$value = _slicedToArray(_step6.value, 2),
+            key = _step6$value[0],
+            value = _step6$value[1];
           var _found2 = false;
-          var _iterator6 = _createForOfIteratorHelper(y),
-            _step6;
+          var _iterator7 = _createForOfIteratorHelper(y),
+            _step7;
           try {
-            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-              var _step6$value = _slicedToArray(_step6.value, 2),
-                otherKey = _step6$value[0],
-                otherValue = _step6$value[1];
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var _step7$value = _slicedToArray(_step7.value, 2),
+                otherKey = _step7$value[0],
+                otherValue = _step7$value[1];
               if (compare(key, otherKey) && compare(value, otherValue)) {
                 _found2 = true;
                 break;
               }
             }
           } catch (err) {
-            _iterator6.e(err);
+            _iterator7.e(err);
           } finally {
-            _iterator6.f();
+            _iterator7.f();
           }
           if (!_found2) {
             return false;
           }
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator6.e(err);
       } finally {
-        _iterator5.f();
+        _iterator6.f();
       }
       return true;
     }

package/module/es5/Validate/isPrimeNumber.js

@@ -18,8 +18,20 @@ var isPrimeNumber = exports.isPrimeNumber = function isPrimeNumber(n) {
   if (n <= 1 || !Number.isInteger(n)) {
     return false;
   }
-  for (var index = 2; index <= Math.sqrt(n); index++) {
-    if (n % index === 0) {
+
+  // Handle small primes and eliminate even numbers / multiples of 3 early
+  if (n <= 3) {
+    return true;
+  }
+  if (n % 2 === 0 || n % 3 === 0) {
+    return false;
+  }
+
+  // Performance: only test divisors of the form 6k +/- 1.
+  // All primes > 3 are of this form, so we skip ~2/3 of candidates
+  // compared to the naive loop that checks every integer from 2 to sqrt(n).
+  for (var index = 5; index * index <= n; index += 6) {
+    if (n % index === 0 || n % (index + 2) === 0) {
       return false;
     }
   }

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

@@ -1,2 +1,4 @@
 export * from "./core";
+export * from "./intersection";
 export * from "./optional";
+export * from "./union";

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

@@ -14,6 +14,17 @@ Object.keys(_core).forEach(function (key) {
     }
   });
 });
+var _intersection = require("./intersection");
+Object.keys(_intersection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _intersection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _intersection[key];
+    }
+  });
+});
 var _optional = require("./optional");
 Object.keys(_optional).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -24,4 +35,15 @@ Object.keys(_optional).forEach(function (key) {
       return _optional[key];
     }
   });
+});
+var _union = require("./union");
+Object.keys(_union).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _union[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _union[key];
+    }
+  });
 });

package/module/es5/Validate/object/intersection.d.ts

@@ -0,0 +1,10 @@
+import type { UnionToIntersection } from "../../types/logic";
+import type { ValidateCoreReturnType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+/**
+ * Creates an intersection validator that passes only if all given validators pass
+ * @param validators - Validator functions to compose as an intersection (logical AND)
+ * @returns {Function} - Validator that checks if the value matches all validators
+ */
+export declare const intersection: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: UnionToIntersection<ExtractValidatedType<Vs[number]>>) => ValidateCoreReturnType<UnionToIntersection<ExtractValidatedType<Vs[number]>>>;
+export {};

package/module/es5/Validate/object/intersection.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.intersection = void 0;
+/**
+ * Creates an intersection validator that passes only if all given validators pass
+ * @param validators - Validator functions to compose as an intersection (logical AND)
+ * @returns {Function} - Validator that checks if the value matches all validators
+ */
+var intersection = exports.intersection = function intersection() {
+  for (var _len = arguments.length, validators = new Array(_len), _key = 0; _key < _len; _key++) {
+    validators[_key] = arguments[_key];
+  }
+  return function (value) {
+    for (var _i = 0, _validators = validators; _i < _validators.length; _i++) {
+      var validator = _validators[_i];
+      var result = validator(value);
+      if (!result.validate) {
+        return {
+          validate: false,
+          message: result.message,
+          type: value
+        };
+      }
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

package/module/es5/Validate/object/optional.d.ts

@@ -1,2 +1,8 @@
 import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Wraps a validator to accept undefined values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make optional
+ * @returns {Function} - Validator that passes for undefined or delegates to the wrapped validator
+ */
 export declare const optional: <T>(validator: (value: T) => ValidateCoreReturnType<T>) => ((value?: T) => ValidateCoreReturnType<T | undefined>);

package/module/es5/Validate/object/optional.js

@@ -4,6 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.optional = void 0;
+/**
+ * Wraps a validator to accept undefined values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make optional
+ * @returns {Function} - Validator that passes for undefined or delegates to the wrapped validator
+ */
 var optional = exports.optional = function optional(validator) {
   var optionalValidator = function optionalValidator(value) {
     if (value === undefined) {

package/module/es5/Validate/object/union.d.ts

@@ -0,0 +1,9 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+/**
+ * Creates a union validator that passes if any of the given validators pass
+ * @param validators - Validator functions to compose as a union (logical OR)
+ * @returns {Function} - Validator that checks if the value matches any of the validators
+ */
+export declare const union: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: ExtractValidatedType<Vs[number]>) => ValidateCoreReturnType<ExtractValidatedType<Vs[number]>>;
+export {};

package/module/es5/Validate/object/union.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.union = void 0;
+/**
+ * Creates a union validator that passes if any of the given validators pass
+ * @param validators - Validator functions to compose as a union (logical OR)
+ * @returns {Function} - Validator that checks if the value matches any of the validators
+ */
+var union = exports.union = function union() {
+  for (var _len = arguments.length, validators = new Array(_len), _key = 0; _key < _len; _key++) {
+    validators[_key] = arguments[_key];
+  }
+  return function (value) {
+    var lastMessage = "";
+    for (var _i = 0, _validators = validators; _i < _validators.length; _i++) {
+      var validator = _validators[_i];
+      var result = validator(value);
+      if (result.validate) {
+        return {
+          validate: true,
+          message: "",
+          type: value
+        };
+      }
+      lastMessage = result.message;
+    }
+    return {
+      validate: false,
+      message: lastMessage,
+      type: value
+    };
+  };
+};

package/module/es5/Validate/parseEmail.js

@@ -33,6 +33,14 @@ var EMAIL_PATTERNS = {
 var parseEmail = exports.parseEmail = function parseEmail(_ref) {
   var email = _ref.email,
     options = _ref.options;
+  // ReDoS mitigation: reject excessively long inputs before regex evaluation
+  // RFC 5321 specifies max 256 characters for a full email address
+  var MAX_EMAIL_LENGTH = 320;
+  if (email.length > MAX_EMAIL_LENGTH) {
+    return {
+      valid: false
+    };
+  }
   var level = options.level;
   var pattern = EMAIL_PATTERNS[level];
   var match = pattern.exec(email);

package/module/es5/Validate/string/uuid.d.ts

@@ -1,11 +1,7 @@
 import type { ValidateReturnType } from "../../Validate/type";
-/**
- * String validation module for UUID strings
- * Provides validation functionality for checking if a string is a valid UUID
- */
 /**
  * Creates a validator for checking if a string is a valid UUID
- * @param {number[]} [versions=[4]] - Array of supported UUID versions
+ * @param {number[]} [versions=[4]] - Array of supported UUID versions (1-7)
  * @param {string} [message] - Custom error message for validation failure
  * @returns {ValidateReturnType<string>} - Validator for UUID strings
  */

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

@@ -11,16 +11,38 @@ function _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.fre
  * Provides validation functionality for checking if a string is a valid UUID
  */
 
+// Security: Valid UUID versions are single-digit integers (1-7).
+// The version value is interpolated into a RegExp constructor, so untrusted
+// input could inject arbitrary regex patterns (regex injection / ReDoS).
+// We validate each version is a safe integer in the expected range before use.
+var VALID_UUID_VERSIONS = new Set([1, 2, 3, 4, 5, 6, 7]);
+
 /**
  * Creates a validator for checking if a string is a valid UUID
- * @param {number[]} [versions=[4]] - Array of supported UUID versions
+ * @param {number[]} [versions=[4]] - Array of supported UUID versions (1-7)
  * @param {string} [message] - Custom error message for validation failure
  * @returns {ValidateReturnType<string>} - Validator for UUID strings
  */
 var uuid = exports.uuid = function uuid() {
   var versions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [4];
   var message = arguments.length > 1 ? arguments[1] : undefined;
-  var versionRegexes = versions.map(function (version) {
+  // Security: Sanitize version input to prevent regex injection.
+  // Only allow known UUID version numbers (integers 1-7) to be interpolated
+  // into the RegExp pattern. Reject anything else to block arbitrary regex
+  // metacharacter injection via untrusted input.
+  var safeVersions = versions.filter(function (v) {
+    return VALID_UUID_VERSIONS.has(v);
+  });
+  if (safeVersions.length === 0) {
+    return {
+      type: "string",
+      message: message,
+      validate: function validate() {
+        return false;
+      }
+    };
+  }
+  var versionRegexes = safeVersions.map(function (version) {
     return new RegExp(String.raw(_templateObject || (_templateObject = _taggedTemplateLiteral(["^[da-f]{8}-?[da-f]{4}-?", "[da-f]{3}-?[89ab][da-f]{3}-?[da-f]{12}$"], ["^[\\da-f]{8}-?[\\da-f]{4}-?", "[\\da-f]{3}-?[89ab][\\da-f]{3}-?[\\da-f]{12}$"])), version), "i");
   });
   return {

package/package.json

@@ -7,38 +7,38 @@
   "devDependencies": {
     "@babel/cli": "7.28.6",
     "@babel/core": "7.29.0",
-    "@babel/preset-env": "7.29.0",
+    "@babel/preset-env": "7.29.2",
     "@babel/preset-typescript": "7.28.5",
-    "@biomejs/biome": "2.4.7",
-    "@codecov/bundle-analyzer": "1.9.1",
+    "@biomejs/biome": "2.4.12",
+    "@codecov/bundle-analyzer": "2.0.1",
     "@eslint/js": "10.0.1",
-    "@swc/core": "1.15.18",
+    "@swc/core": "1.15.30",
     "@swc/jest": "0.2.39",
-    "@types/bun": "1.3.10",
+    "@types/bun": "1.3.12",
     "@types/jest": "30.0.0",
     "@types/lodash": "4.17.24",
-    "@types/node": "25.5.0",
-    "@typescript-eslint/eslint-plugin": "8.57.0",
-    "@typescript-eslint/parser": "8.57.0",
-    "bun-types": "1.3.10",
-    "dependency-cruiser": "17.3.9",
+    "@types/node": "25.6.0",
+    "@typescript-eslint/eslint-plugin": "8.58.2",
+    "@typescript-eslint/parser": "8.58.2",
+    "bun-types": "1.3.12",
+    "dependency-cruiser": "17.3.10",
     "es-toolkit": "1.45.1",
-    "eslint": "10.0.3",
-    "eslint-plugin-baseline-js": "0.6.1",
+    "eslint": "10.2.1",
+    "eslint-plugin-baseline-js": "0.6.2",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-unicorn": "63.0.0",
+    "eslint-plugin-unicorn": "64.0.0",
     "fast-sort": "3.4.1",
     "gh-pages": "6.3.0",
     "jest": "30.3.0",
     "jest-junit": "16.0.0",
-    "lodash": "4.17.23",
+    "lodash": "4.18.1",
     "mitata": "1.0.34",
-    "ts-jest": "29.4.6",
+    "ts-jest": "29.4.9",
     "ts-node": "10.9.2",
     "tsc-alias": "1.8.16",
-    "typedoc": "0.28.17",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.57.0"
+    "typedoc": "0.28.19",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.58.2"
   },
   "exports": {
     ".": {
@@ -218,5 +218,5 @@
   },
   "type": "module",
   "types": "module/index.d.ts",
-  "version": "2.14.0"
+  "version": "2.16.0"
 }