umt 2.12.3 → 2.14.0

package/module/es5/Object/index.js

@@ -3,6 +3,39 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _deepClone = require("./deepClone");
+Object.keys(_deepClone).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _deepClone[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _deepClone[key];
+    }
+  });
+});
+var _getObjectsCommon = require("./getObjectsCommon");
+Object.keys(_getObjectsCommon).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getObjectsCommon[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _getObjectsCommon[key];
+    }
+  });
+});
+var _getObjectsDiff = require("./getObjectsDiff");
+Object.keys(_getObjectsDiff).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getObjectsDiff[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _getObjectsDiff[key];
+    }
+  });
+});
 var _has = require("./has");
 Object.keys(_has).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -25,6 +58,17 @@ Object.keys(_isEmpty).forEach(function (key) {
     }
   });
 });
+var _isPlainObject = require("./isPlainObject");
+Object.keys(_isPlainObject).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isPlainObject[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _isPlainObject[key];
+    }
+  });
+});
 var _keyBy = require("./keyBy");
 Object.keys(_keyBy).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -36,6 +80,28 @@ Object.keys(_keyBy).forEach(function (key) {
     }
   });
 });
+var _mapKeys = require("./mapKeys");
+Object.keys(_mapKeys).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mapKeys[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mapKeys[key];
+    }
+  });
+});
+var _mapValues = require("./mapValues");
+Object.keys(_mapValues).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mapValues[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mapValues[key];
+    }
+  });
+});
 var _merge = require("./merge");
 Object.keys(_merge).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Object/isPlainObject.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if a value is a plain object (created by Object constructor
+ * or with a null prototype).
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a plain object, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * isPlainObject({});          // true
+ * isPlainObject({ a: 1 });    // true
+ * isPlainObject(new Map());   // false
+ * isPlainObject(null);        // false
+ * ```
+ */
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;

package/module/es5/Object/isPlainObject.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPlainObject = void 0;
+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); }
+/**
+ * Checks if a value is a plain object (created by Object constructor
+ * or with a null prototype).
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a plain object, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * isPlainObject({});          // true
+ * isPlainObject({ a: 1 });    // true
+ * isPlainObject(new Map());   // false
+ * isPlainObject(null);        // false
+ * ```
+ */
+var isPlainObject = exports.isPlainObject = function isPlainObject(value) {
+  if (value === null || _typeof(value) !== "object") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(value);
+  if (prototype === null) {
+    return true;
+  }
+  if (prototype === Object.prototype) {
+    return true;
+  }
+
+  // Handle objects created via Object.create(plainObject)
+  // Check constructor on the prototype to avoid own-property shadowing
+  var protoConstructor = prototype.constructor;
+  return typeof protoConstructor === "function" && protoConstructor === Object;
+};

package/module/es5/Object/mapKeys.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates an object with the same values as the given object, but
+ * with keys transformed by the provided function.
+ *
+ * @param object - The source object.
+ * @param function_ - The function invoked per key. Receives (value, key).
+ * @returns A new object with transformed keys.
+ *
+ * @example
+ * ```typescript
+ * mapKeys({ a: 1, b: 2 }, (_value, key) => key.toUpperCase());
+ * // { A: 1, B: 2 }
+ * ```
+ */
+export declare const mapKeys: <T extends Record<string, unknown>>(object: T, function_: (value: T[keyof T], key: string) => string) => Record<string, T[keyof T]>;

package/module/es5/Object/mapKeys.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mapKeys = void 0;
+/**
+ * Creates an object with the same values as the given object, but
+ * with keys transformed by the provided function.
+ *
+ * @param object - The source object.
+ * @param function_ - The function invoked per key. Receives (value, key).
+ * @returns A new object with transformed keys.
+ *
+ * @example
+ * ```typescript
+ * mapKeys({ a: 1, b: 2 }, (_value, key) => key.toUpperCase());
+ * // { A: 1, B: 2 }
+ * ```
+ */
+var mapKeys = exports.mapKeys = function mapKeys(object, function_) {
+  var result = {};
+  var keys = Object.keys(object);
+  var length = keys.length;
+  var index = 0;
+  while (index < length) {
+    var key = keys[index];
+    var value = object[key];
+    result[function_(value, key)] = value;
+    index += 1;
+  }
+  return result;
+};

package/module/es5/Object/mapValues.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates an object with the same keys as the given object, but
+ * with values transformed by the provided function.
+ *
+ * @param object - The source object.
+ * @param function_ - The function invoked per value. Receives (value, key).
+ * @returns A new object with transformed values.
+ *
+ * @example
+ * ```typescript
+ * mapValues({ a: 1, b: 2 }, (value) => value * 2);
+ * // { a: 2, b: 4 }
+ * ```
+ */
+export declare const mapValues: <T extends Record<string, unknown>, R>(object: T, function_: (value: T[keyof T], key: string) => R) => Record<keyof T, R>;

package/module/es5/Object/mapValues.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mapValues = void 0;
+/**
+ * Creates an object with the same keys as the given object, but
+ * with values transformed by the provided function.
+ *
+ * @param object - The source object.
+ * @param function_ - The function invoked per value. Receives (value, key).
+ * @returns A new object with transformed values.
+ *
+ * @example
+ * ```typescript
+ * mapValues({ a: 1, b: 2 }, (value) => value * 2);
+ * // { a: 2, b: 4 }
+ * ```
+ */
+var mapValues = exports.mapValues = function mapValues(object, function_) {
+  var result = {};
+  var keys = Object.keys(object);
+  var length = keys.length;
+  var index = 0;
+  while (index < length) {
+    var key = keys[index];
+    result[key] = function_(object[key], key);
+    index += 1;
+  }
+  return result;
+};

package/module/es5/Object/mergeDeep.js

@@ -4,19 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.mergeDeep = void 0;
+var _isPlainObject = require("../Object/isPlainObject");
+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 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); }
-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); }
-/**
- * Checks if a value is a plain object
- */
-var isPlainObject = function isPlainObject(value) {
-  return value !== null && _typeof(value) === "object" && value.constructor === Object && Object.prototype.toString.call(value) === "[object Object]";
-};
-
 /**
  * Deeply merges multiple objects into a single object
  * @param target - The target object to merge into
@@ -31,13 +25,16 @@ var _mergeDeep = exports.mergeDeep = function mergeDeep(target) {
     return target;
   }
   var source = sources.shift();
-  if (isPlainObject(target) && isPlainObject(source)) {
+  if ((0, _isPlainObject.isPlainObject)(target) && (0, _isPlainObject.isPlainObject)(source)) {
     var result = _objectSpread({}, target);
     for (var key in source) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        continue;
+      }
       if (Object.hasOwn(source, key)) {
         var sourceValue = source[key];
         var targetValue = result[key];
-        result[key] = isPlainObject(targetValue) && isPlainObject(sourceValue) ? _mergeDeep(targetValue, sourceValue) : sourceValue;
+        result[key] = (0, _isPlainObject.isPlainObject)(targetValue) && (0, _isPlainObject.isPlainObject)(sourceValue) ? _mergeDeep(targetValue, sourceValue) : sourceValue;
       }
     }
     return _mergeDeep.apply(void 0, [result].concat(sources));

package/module/es5/Object/omit.d.ts

@@ -4,4 +4,4 @@
  * @param keys - The keys to omit
  * @returns A new object without the specified keys
  */
-export declare const omit: <T extends object, K extends keyof T>(object: T, ...keys: K[]) => Omit<T, K>;
+export declare const omit: <T extends object, K extends keyof T>(object: T, ...keys: (keyof T)[]) => Omit<T, K>;

package/module/es5/Object/pickDeep.js

@@ -12,11 +12,6 @@ function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 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; }
-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); }
 /**
  * Creates a new object by deeply selecting properties from the source object based on specified keys.
  *
@@ -43,7 +38,7 @@ var pickDeep = exports.pickDeep = function pickDeep(object) {
     var key = _keys[_i];
     var parts = key.split(".");
     // biome-ignore lint/suspicious/noExplicitAny: ignore
-    var current = _objectSpread({}, object);
+    var current = object;
     // biome-ignore lint/suspicious/noExplicitAny: ignore
     var target = result;
     var _iterator = _createForOfIteratorHelper(parts.entries()),
@@ -53,6 +48,9 @@ var pickDeep = exports.pickDeep = function pickDeep(object) {
         var _step$value = _slicedToArray(_step.value, 2),
           index = _step$value[0],
           part = _step$value[1];
+        if (part === "__proto__" || part === "constructor" || part === "prototype") {
+          continue;
+        }
         if (current && _typeof(current) === "object" && part in current) {
           if (index === parts.length - 1) {
             target[part] = current[part];

package/module/es5/Predicate/every.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Creates a predicate that returns true only when all given
+ * predicates return true, using short-circuit evaluation
+ * @param {((...arguments_: T) => boolean)[]} predicates - The predicates to combine
+ * @returns {(...arguments_: T) => boolean} A combined predicate
+ * @example
+ * const isPositiveEven = every(
+ *   (n: number) => n > 0,
+ *   (n: number) => n % 2 === 0,
+ * );
+ * isPositiveEven(4); // true
+ * isPositiveEven(-2); // false
+ */
+export declare const every: <T extends unknown[]>(...predicates: ((...arguments_: T) => boolean)[]) => ((...arguments_: T) => boolean);

package/module/es5/Predicate/every.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.every = void 0;
+/**
+ * Creates a predicate that returns true only when all given
+ * predicates return true, using short-circuit evaluation
+ * @param {((...arguments_: T) => boolean)[]} predicates - The predicates to combine
+ * @returns {(...arguments_: T) => boolean} A combined predicate
+ * @example
+ * const isPositiveEven = every(
+ *   (n: number) => n > 0,
+ *   (n: number) => n % 2 === 0,
+ * );
+ * isPositiveEven(4); // true
+ * isPositiveEven(-2); // false
+ */
+var every = exports.every = function every() {
+  for (var _len = arguments.length, predicates = new Array(_len), _key = 0; _key < _len; _key++) {
+    predicates[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _i = 0, _predicates = predicates; _i < _predicates.length; _i++) {
+      var predicate = _predicates[_i];
+      if (!predicate.apply(void 0, arguments)) {
+        return false;
+      }
+    }
+    return true;
+  };
+};

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

@@ -0,0 +1,6 @@
+export * from "./every";
+export * from "./isNotNullish";
+export * from "./isNullish";
+export * from "./matches";
+export * from "./not";
+export * from "./some";

package/module/es5/Predicate/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _every = require("./every");
+Object.keys(_every).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _every[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _every[key];
+    }
+  });
+});
+var _isNotNullish = require("./isNotNullish");
+Object.keys(_isNotNullish).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isNotNullish[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _isNotNullish[key];
+    }
+  });
+});
+var _isNullish = require("./isNullish");
+Object.keys(_isNullish).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isNullish[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _isNullish[key];
+    }
+  });
+});
+var _matches = require("./matches");
+Object.keys(_matches).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _matches[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _matches[key];
+    }
+  });
+});
+var _not = require("./not");
+Object.keys(_not).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _not[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _not[key];
+    }
+  });
+});
+var _some = require("./some");
+Object.keys(_some).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _some[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _some[key];
+    }
+  });
+});

package/module/es5/Predicate/isNotNullish.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks whether a value is null or undefined
+ * @param {unknown} value - The value to check
+ * @returns {boolean} True if the value is null or undefined
+ * @example
+ * isNotNullish(null); // false
+ * isNotNullish(undefined); // false
+ * isNotNullish(0); // true
+ * isNotNullish(""); // true
+ */
+export declare const isNotNullish: <T>(value: T) => value is Exclude<T, null | undefined>;

package/module/es5/Predicate/isNotNullish.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNotNullish = void 0;
+/**
+ * Checks whether a value is null or undefined
+ * @param {unknown} value - The value to check
+ * @returns {boolean} True if the value is null or undefined
+ * @example
+ * isNotNullish(null); // false
+ * isNotNullish(undefined); // false
+ * isNotNullish(0); // true
+ * isNotNullish(""); // true
+ */
+var isNotNullish = exports.isNotNullish = function isNotNullish(value) {
+  return value !== null && value !== undefined;
+};

package/module/es5/Predicate/isNullish.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks whether a value is null or undefined
+ * @param {unknown} value - The value to check
+ * @returns {boolean} True if the value is null or undefined
+ * @example
+ * isNullish(null); // true
+ * isNullish(undefined); // true
+ * isNullish(0); // false
+ * isNullish(""); // false
+ */
+export declare const isNullish: (value: unknown) => value is null | undefined;

package/module/es5/Predicate/isNullish.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNullish = void 0;
+/**
+ * Checks whether a value is null or undefined
+ * @param {unknown} value - The value to check
+ * @returns {boolean} True if the value is null or undefined
+ * @example
+ * isNullish(null); // true
+ * isNullish(undefined); // true
+ * isNullish(0); // false
+ * isNullish(""); // false
+ */
+var isNullish = exports.isNullish = function isNullish(value) {
+  return value === null || value === undefined;
+};

package/module/es5/Predicate/matches.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a predicate that checks whether an object matches
+ * all properties of the given pattern using strict equality
+ * @param {Record<string, unknown>} pattern - The pattern to match against
+ * @returns {(obj: Record<string, unknown>) => boolean} A predicate that tests objects
+ * @example
+ * const isAdmin = matches({ role: "admin" });
+ * isAdmin({ name: "Alice", role: "admin" }); // true
+ * isAdmin({ name: "Bob", role: "user" }); // false
+ */
+export declare const matches: (pattern: Record<string, unknown>) => ((object: Record<string, unknown>) => boolean);

package/module/es5/Predicate/matches.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matches = void 0;
+/**
+ * Creates a predicate that checks whether an object matches
+ * all properties of the given pattern using strict equality
+ * @param {Record<string, unknown>} pattern - The pattern to match against
+ * @returns {(obj: Record<string, unknown>) => boolean} A predicate that tests objects
+ * @example
+ * const isAdmin = matches({ role: "admin" });
+ * isAdmin({ name: "Alice", role: "admin" }); // true
+ * isAdmin({ name: "Bob", role: "user" }); // false
+ */
+var matches = exports.matches = function matches(pattern) {
+  return function (object) {
+    var keys = Object.keys(pattern);
+    for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
+      var key = _keys[_i];
+      if (object[key] !== pattern[key]) {
+        return false;
+      }
+    }
+    return true;
+  };
+};

package/module/es5/Predicate/not.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a predicate that negates the given predicate
+ * @param {(...arguments_: T) => boolean} function_ - The predicate to negate
+ * @returns {(...arguments_: T) => boolean} A new predicate that returns the opposite
+ * @example
+ * const isEven = (n: number) => n % 2 === 0;
+ * const isOdd = not(isEven);
+ * isOdd(3); // true
+ */
+export declare const not: <T extends unknown[]>(function_: (...arguments_: T) => boolean) => ((...arguments_: T) => boolean);

package/module/es5/Predicate/not.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.not = void 0;
+/**
+ * Creates a predicate that negates the given predicate
+ * @param {(...arguments_: T) => boolean} function_ - The predicate to negate
+ * @returns {(...arguments_: T) => boolean} A new predicate that returns the opposite
+ * @example
+ * const isEven = (n: number) => n % 2 === 0;
+ * const isOdd = not(isEven);
+ * isOdd(3); // true
+ */
+var not = exports.not = function not(function_) {
+  return function () {
+    return !function_.apply(void 0, arguments);
+  };
+};

package/module/es5/Predicate/some.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a predicate that returns true when at least one of
+ * the given predicates returns true, using short-circuit evaluation
+ * @param {((...arguments_: T) => boolean)[]} predicates - The predicates to combine
+ * @returns {(...arguments_: T) => boolean} A combined predicate
+ * @example
+ * const isZeroOrNegative = some(
+ *   (n: number) => n === 0,
+ *   (n: number) => n < 0,
+ * );
+ * isZeroOrNegative(0); // true
+ * isZeroOrNegative(-1); // true
+ * isZeroOrNegative(1); // false
+ */
+export declare const some: <T extends unknown[]>(...predicates: ((...arguments_: T) => boolean)[]) => ((...arguments_: T) => boolean);

package/module/es5/Predicate/some.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.some = void 0;
+/**
+ * Creates a predicate that returns true when at least one of
+ * the given predicates returns true, using short-circuit evaluation
+ * @param {((...arguments_: T) => boolean)[]} predicates - The predicates to combine
+ * @returns {(...arguments_: T) => boolean} A combined predicate
+ * @example
+ * const isZeroOrNegative = some(
+ *   (n: number) => n === 0,
+ *   (n: number) => n < 0,
+ * );
+ * isZeroOrNegative(0); // true
+ * isZeroOrNegative(-1); // true
+ * isZeroOrNegative(1); // false
+ */
+var some = exports.some = function some() {
+  for (var _len = arguments.length, predicates = new Array(_len), _key = 0; _key < _len; _key++) {
+    predicates[_key] = arguments[_key];
+  }
+  return function () {
+    for (var _i = 0, _predicates = predicates; _i < _predicates.length; _i++) {
+      var predicate = _predicates[_i];
+      if (predicate.apply(void 0, arguments)) {
+        return true;
+      }
+    }
+    return false;
+  };
+};

package/module/es5/String/camelCase.js

@@ -10,9 +10,9 @@ exports.camelCase = void 0;
  * @returns The camelCase string
  */
 var camelCase = exports.camelCase = function camelCase(string_) {
-  return string_.replaceAll(/[^a-zA-Z0-9]+(.)/g, function (_, _char) {
+  return string_.replaceAll(/[^\dA-Za-z]+(.)/g, function (_, _char) {
     return _char.toUpperCase();
-  }).replaceAll(/[^a-zA-Z0-9]+$/g, "").replace(/^[A-Z]/, function (_char2) {
+  }).replaceAll(/[^\dA-Za-z]+$/g, "").replace(/^[A-Z]/, function (_char2) {
     return _char2.toLowerCase();
   });
 };