@rzl-zone/utils-js 3.12.0 → 3.12.1-beta.0

package/dist/predicates/index.js

@@ -1,26 +1,24 @@
 /*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-export { areArraysEqual, areObjectsEqual, areURLsEqualPath, areURLsIdentical, arrayHasAnyMatch, doesKeyExist, isArguments, isArrayLike, isArrayLikeObject, isCurrencyLike, isDeepEqual, isElement, isEmpty, isEmptyDeep, isEqualWith, isLength, isMatch, isMatchWith, isNative, isObjectLoose, isPropertyKey, isSafeInteger, isValidURL, isWeakMap, textContainsAll, textContainsAny } from '../chunk-TULOI4GL.js';
-export { isURL } from '../chunk-ONZFBJVW.js';
-export { isNonEmptyValue, isTypedArray } from '../chunk-KIDJCMNJ.js';
-export { isEmptyValue } from '../chunk-QFFBIOJ4.js';
-export { isServer } from '../chunk-L5RDAVVH.js';
-import '../chunk-5MGEC3YG.js';
-export { isFinite } from '../chunk-NODTV4F3.js';
-export { isInteger } from '../chunk-WVSPXFTY.js';
-export { isValidDomain } from '../chunk-BXW7YXB7.js';
-import '../chunk-44XX2P34.js';
-export { isEmptyString } from '../chunk-TCDOWZQE.js';
-import '../chunk-BKIJBNIE.js';
-export { isArrayBuffer, isEqual, isRegExp } from '../chunk-WYP76WXB.js';
-export { isEmptyArray, isEmptyObject } from '../chunk-SDMPEJ4F.js';
-export { isDate, isMap } from '../chunk-6VUXD3CF.js';
-export { isBigInt } from '../chunk-QNKGP5DY.js';
-export { getPreciseType, hasOwnProp, isArray, isBoolean, isBooleanObject, isBuffer, isError, isFunction, isInfinityNumber, isNaN, isNil, isNonEmptyArray, isNonEmptyString, isNull, isNumber, isNumberObject, isObject, isObjectOrArray, isPlainObject, isSet, isString, isStringObject, isSymbol, isUndefined } from '../chunk-CSG4SCL3.js';
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+import { A as isPlainObject, C as isSymbol, D as isNaN, E as isNull, F as isBoolean, M as isArray, N as isNil, O as isNumberObject, P as isFunction, S as isUndefined, _ as isBuffer, b as hasOwnProp, f as isSet, g as isStringObject, h as isBooleanObject, j as isObject, k as isString, m as isInfinityNumber, p as isNonEmptyArray, r as getPreciseType, v as isError, w as isNumber, x as isObjectOrArray, y as isNonEmptyString } from "../assertIsBoolean-BlBct0Fc.js";
+import { t as isBigInt } from "../isBigInt-C0bN0Rhu.js";
+import { n as isEmptyArray, t as isEmptyObject } from "../isEmptyObject-DeLVIJpl.js";
+import { t as isFinite } from "../isFinite-BYMOo0os.js";
+import { n as isDate, r as isMap } from "../safeStableStringify-BNh3D0K0.js";
+import { i as isRegExp, r as isArrayBuffer, t as isEqual } from "../isEqual-DhyP8fB_.js";
+import { t as isEmptyString } from "../isEmptyString-BTUWYTbw.js";
+import { t as isEmptyValue } from "../isEmptyValue-fjnfQnt5.js";
+import { n as isNonEmptyValue, t as isTypedArray } from "../isTypedArray-47R0wdrc.js";
+import { t as isServer } from "../isServer-D1TXfOs3.js";
+import { t as isInteger } from "../isInteger-DS9V7l_f.js";
+import { C as areURLsIdentical, E as areArraysEqual, S as textContainsAll, T as areObjectsEqual, _ as isArguments, a as isNative, b as isPropertyKey, c as isEqualWith, d as isElement, f as isDeepEqual, g as isLength, h as isArrayLike, i as isObjectLoose, l as isEmptyDeep, m as isArrayLikeObject, n as isValidURL, o as isMatch, p as isCurrencyLike, r as isSafeInteger, s as isMatchWith, t as isWeakMap, u as isEmpty, v as arrayHasAnyMatch, w as areURLsEqualPath, x as textContainsAny, y as doesKeyExist } from "../predicates-gNepszvo.js";
+import { t as isURL } from "../isURL-CQiowFq2.js";
+import { t as isValidDomain } from "../isValidDomain-DwA2EN79.js";
+export { areArraysEqual, areObjectsEqual, areURLsEqualPath, areURLsIdentical, arrayHasAnyMatch, doesKeyExist, getPreciseType, hasOwnProp, isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBigInt, isBoolean, isBooleanObject, isBuffer, isCurrencyLike, isDate, isDeepEqual, isElement, isEmpty, isEmptyArray, isEmptyDeep, isEmptyObject, isEmptyString, isEmptyValue, isEqual, isEqualWith, isError, isFinite, isFunction, isInfinityNumber, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNonEmptyArray, isNonEmptyString, isNonEmptyValue, isNull, isNumber, isNumberObject, isObject, isObjectLoose, isObjectOrArray, isPlainObject, isPropertyKey, isRegExp, isSafeInteger, isServer, isSet, isString, isStringObject, isSymbol, isTypedArray, isURL, isUndefined, isValidDomain, isValidURL, isWeakMap, textContainsAll, textContainsAny };

package/dist/predicates-DiaYA7Ps.cjs

@@ -0,0 +1,413 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+"use strict";
+const require_assertIsBoolean = require('./assertIsBoolean-DozdtbNi.cjs');
+const require_assertIsString = require('./assertIsString-Bvk7bUL7.cjs');
+const require_isEmptyObject = require('./isEmptyObject-DI42NEo0.cjs');
+const require_safeStableStringify = require('./safeStableStringify-Cc62pfRp.cjs');
+const require_isEqual = require('./isEqual-B1fRgEuU.cjs');
+const require_isEmptyString = require('./isEmptyString-CCK3bP74.cjs');
+const require_isTypedArray = require('./isTypedArray-DiCoqffZ.cjs');
+const require_parsing = require('./parsing-lRoxn1Nz.cjs');
+const require_isURL = require('./isURL-WZypXsax.cjs');
+const areArraysEqual = (array1, array2, ignoreOrder = false) => {
+	if (!(require_assertIsBoolean.isArray(array1) && require_assertIsBoolean.isArray(array2))) throw new TypeError(`Parameters \`array1\` and \`array2\` property of the \`options\` (second parameter) must be of type \`array\`, but received: ['array1': \`${require_assertIsBoolean.getPreciseType(array1)}\`, 'array2': \`${require_assertIsBoolean.getPreciseType(array2)}\`].`);
+	require_assertIsBoolean.assertIsBoolean(ignoreOrder, { message: ({ currentType, validType }) => `Third parameter \`ignoreOrder\` must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	if (!require_isEqual.isEqual(array1.length, array2.length)) return false;
+	const deepIgnoreOrder = (arr) => {
+		if (!require_assertIsBoolean.isArray(arr)) return arr;
+		return arr.map((item) => {
+			if (require_assertIsBoolean.isArray(item)) return deepIgnoreOrder(item);
+			return item;
+		}).sort((a, b) => {
+			const sa = require_safeStableStringify.safeStableStringify(a);
+			const sb = require_safeStableStringify.safeStableStringify(b);
+			return sa < sb ? -1 : sa > sb ? 1 : 0;
+		});
+	};
+	const normalizedArr1 = ignoreOrder ? deepIgnoreOrder(array1) : array1;
+	const normalizedArr2 = ignoreOrder ? deepIgnoreOrder(array2) : array2;
+	if (!require_isEqual.isEqual(normalizedArr1.length, normalizedArr2.length)) return false;
+	return normalizedArr1.every((item, index) => require_safeStableStringify.safeStableStringify(item) === require_safeStableStringify.safeStableStringify(normalizedArr2[index]));
+};
+const areObjectsEqual = (object1, object2) => {
+	return require_isEqual.isEqual(object1, object2);
+};
+const areURLsEqualPath = (urlA, urlB) => {
+	if (!require_isURL.isURL(urlA) || !require_isURL.isURL(urlB)) throw new TypeError("Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.");
+	return urlA.protocol + "//" + urlA.host + urlA.pathname === urlB.protocol + "//" + urlB.host + urlB.pathname;
+};
+const areURLsIdentical = (urlA, urlB) => {
+	if (!require_isURL.isURL(urlA) || !require_isURL.isURL(urlB)) throw new TypeError("Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.");
+	return urlA.protocol + "//" + urlA.host + urlA.pathname + urlA.search === urlB.protocol + "//" + urlB.host + urlB.pathname + urlB.search;
+};
+const textContainsAll = (text, searchWords, options = {}) => {
+	if (!require_assertIsBoolean.isNonEmptyString(text) || !require_assertIsBoolean.isArray(searchWords)) return false;
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Third parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const { exactMatch = false, flags = "i" } = options;
+	require_assertIsBoolean.assertIsBoolean(exactMatch, { message: ({ currentType, validType }) => `Parameter \`exactMatch\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	require_assertIsString.assertIsString(flags, { message: ({ currentType, validType }) => `Parameter \`flags\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const validSearchWords = searchWords.filter((word) => require_assertIsBoolean.isNonEmptyString(word)).map(escapeRegex);
+	if (validSearchWords.length === 0) return false;
+	return validSearchWords.every((word) => {
+		const pattern = exactMatch ? `(?<!\\S)${word}(?!\\S)` : word;
+		return new RegExp(pattern, flags.includes("u") ? flags : flags + "u").test(text);
+	});
+};
+const textContainsAny = (text, searchWords, options = {}) => {
+	if (!require_assertIsBoolean.isNonEmptyString(text) || !require_assertIsBoolean.isArray(searchWords)) return false;
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Third parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const { exactMatch = false, flags = "i" } = options;
+	require_assertIsBoolean.assertIsBoolean(exactMatch, { message: ({ currentType, validType }) => `Parameter \`exactMatch\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	require_assertIsString.assertIsString(flags, { message: ({ currentType, validType }) => `Parameter \`flags\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const validSearchWords = searchWords.filter((word) => require_assertIsBoolean.isNonEmptyString(word)).map(escapeRegex);
+	if (validSearchWords.length === 0) return false;
+	const pattern = exactMatch ? `(?<!\\S)(${validSearchWords.join("|")})(?!\\S)` : `(${validSearchWords.join("|")})`;
+	return new RegExp(pattern, flags.includes("u") ? flags : flags + "u").test(text);
+};
+function isPropertyKey(value) {
+	const type = typeof value;
+	return type === "string" || type === "number" || type === "symbol";
+}
+const doesKeyExist = (object, key) => {
+	if (!require_assertIsBoolean.isObjectOrArray(object)) return false;
+	if (!isPropertyKey(key)) throw new TypeError(`Second Parameter (\`key\`) must be of type \`string\`, \`number\` or \`symbol\`, but received: \`${require_assertIsBoolean.getPreciseType(key)}\`.`);
+	if (Object.prototype.hasOwnProperty.call(object, key)) return true;
+	if (require_assertIsBoolean.isArray(object)) return object.some((item) => doesKeyExist(item, key));
+	return Object.values(object).some((value) => require_assertIsBoolean.isObjectOrArray(value) && doesKeyExist(value, key));
+};
+const arrayHasAnyMatch = (sourceArray, targetArray) => {
+	if (!require_assertIsBoolean.isArray(sourceArray) || !require_assertIsBoolean.isArray(targetArray) || require_isEmptyObject.isEmptyArray(sourceArray) || require_isEmptyObject.isEmptyArray(targetArray)) return false;
+	const sourceSet = new Set(sourceArray);
+	return targetArray.some((item) => sourceSet.has(item));
+};
+const isArguments = (value) => {
+	return Object.prototype.toString.call(value) === "[object Arguments]";
+};
+function isLength(value) {
+	return typeof value === "number" && value > -1 && Number.isInteger(value) && value <= Number.MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+	return !require_assertIsBoolean.isFunction(value) && require_assertIsBoolean.isObjectOrArray(value) && isLength(value?.length);
+}
+function isArrayLikeObject(value) {
+	return require_assertIsBoolean.isObjectOrArray(value) && isLength(value.length);
+}
+const isCurrencyLike = (input) => {
+	if (!(require_assertIsBoolean.isString(input) || require_assertIsBoolean.isNumber(input))) return false;
+	if (require_parsing.parseCurrencyString(input.toString()) !== 0) return true;
+	return input.toString().trim() === "0";
+};
+const isDeepEqual = (a, b) => {
+	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (require_safeStableStringify.isDate(a) && require_safeStableStringify.isDate(b)) return a.getTime() === b.getTime();
+	if (require_isEqual.isRegExp(a) && require_isEqual.isRegExp(b)) return a.toString() === b.toString();
+	if (require_assertIsBoolean.isSymbol(a) && require_assertIsBoolean.isSymbol(b)) return a.toString() === b.toString();
+	if (require_assertIsBoolean.isSet(a) && require_assertIsBoolean.isSet(b)) {
+		if (a.size !== b.size) return false;
+		const bValues = Array.from(b);
+		const matched = /* @__PURE__ */ new Set();
+		for (const aVal of a) {
+			let found = false;
+			for (let i = 0; i < bValues.length; i++) {
+				if (matched.has(i)) continue;
+				if (isDeepEqual(aVal, bValues[i])) {
+					matched.add(i);
+					found = true;
+					break;
+				}
+			}
+			if (!found) return false;
+		}
+		return true;
+	}
+	if (require_safeStableStringify.isMap(a) && require_safeStableStringify.isMap(b)) {
+		if (a.size !== b.size) return false;
+		const bEntries = Array.from(b);
+		const matched = /* @__PURE__ */ new Set();
+		for (const [aKey, aVal] of a) {
+			let found = false;
+			for (let i = 0; i < bEntries.length; i++) {
+				if (matched.has(i)) continue;
+				const [bKey, bVal] = bEntries[i];
+				if (isDeepEqual(aKey, bKey) && isDeepEqual(aVal, bVal)) {
+					matched.add(i);
+					found = true;
+					break;
+				}
+			}
+			if (!found) return false;
+		}
+		return true;
+	}
+	if (require_assertIsBoolean.isArray(a) && require_assertIsBoolean.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((item, i) => isDeepEqual(item, b[i]));
+	}
+	if (require_assertIsBoolean.isObjectOrArray(a) && require_assertIsBoolean.isObjectOrArray(b) && a && b) {
+		if (require_assertIsBoolean.isArray(a) !== require_assertIsBoolean.isArray(b)) return false;
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys.length !== bKeys.length) return false;
+		return aKeys.every((key) => isDeepEqual(a[key], b[key]));
+	}
+	return false;
+};
+function isElement(value) {
+	return !!value && typeof value === "object" && value?.nodeType === 1 && !require_assertIsBoolean.isPlainObject(value);
+}
+function isEmpty(value) {
+	if (require_assertIsBoolean.isNil(value)) return true;
+	if (require_assertIsBoolean.isBoolean(value) || require_assertIsBoolean.isNumber(value, { includeNaN: true }) || require_assertIsBoolean.isSymbol(value)) return true;
+	if (require_assertIsBoolean.isFunction(value)) return Object.keys(value).length === 0;
+	if (require_assertIsBoolean.isString(value) || require_assertIsBoolean.isArray(value) || isArguments(value) || require_isTypedArray.isTypedArray(value)) return value.length === 0;
+	if (require_safeStableStringify.isMap(value) || require_assertIsBoolean.isSet(value)) return value.size === 0;
+	if (require_assertIsBoolean.isBuffer(value)) return value.length === 0;
+	if (require_assertIsBoolean.isPlainObject(value)) return Object.keys(value).length === 0;
+	return false;
+}
+const isEmptyDeep = (value) => {
+	if (require_assertIsBoolean.isString(value)) return require_isEmptyString.isEmptyString(value);
+	if (require_assertIsBoolean.isNumber(value)) return require_assertIsBoolean.isNaN(value);
+	if (require_assertIsBoolean.isArray(value)) return require_isEmptyObject.isEmptyArray(value) || value.every(isEmptyDeep);
+	if (require_assertIsBoolean.isObjectOrArray(value)) {
+		const keys = Object.keys(value);
+		const symbols = Object.getOwnPropertySymbols(value);
+		if (keys.length === 0 && symbols.length === 0) return true;
+		return [...keys, ...symbols].every((key) => isEmptyDeep(value[key]));
+	}
+	if (!value) return true;
+	return false;
+};
+function isEqualWith(value, other, customizer) {
+	return require_isEqual.baseDeepEqual(value, other, customizer, /* @__PURE__ */ new WeakMap());
+}
+function isMatchWith(value, other, customizer) {
+	return baseIsMatch(value, other, customizer);
+}
+function isSameValue(x, y) {
+	return x === y || x === 0 && y === 0 || Number.isNaN(x) && Number.isNaN(y);
+}
+function baseIsMatch(object, source, customizer) {
+	if (object === source) return true;
+	if (!require_assertIsBoolean.isObjectOrArray(source)) return isSameValue(object, source);
+	if (!require_assertIsBoolean.isObjectOrArray(object)) return false;
+	const keys = Reflect.ownKeys(source).filter((k) => !(require_assertIsBoolean.isArray(source) && k === "length"));
+	for (const key of keys) {
+		if (!(key in object)) return false;
+		const objValue = object[key];
+		const srcValue = source[key];
+		const result = customizer?.(objValue, srcValue, key, object, source);
+		if (!require_assertIsBoolean.isUndefined(result)) {
+			if (!result) return false;
+			continue;
+		}
+		if (require_assertIsBoolean.isObjectOrArray(objValue) && require_assertIsBoolean.isObjectOrArray(srcValue)) {
+			if (!isMatchWith(objValue, srcValue, customizer)) return false;
+		} else if (!isSameValue(objValue, srcValue)) return false;
+	}
+	return true;
+}
+function isMatch(object, source) {
+	return baseIsMatch(object, source);
+}
+const funcToString = Function.prototype.toString;
+const reIsNative = /\{\s*\[native code\]\s*\}/;
+function isNative(value) {
+	if (!require_assertIsBoolean.isFunction(value)) return false;
+	try {
+		const source = funcToString.call(value);
+		return reIsNative.test(source);
+	} catch {
+		return false;
+	}
+}
+function isObjectLoose(value) {
+	return !require_assertIsBoolean.isNil(value) && (require_assertIsBoolean.isObjectOrArray(value) || require_assertIsBoolean.isFunction(value));
+}
+function isSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value);
+}
+const isValidURL = (url) => {
+	if (!require_assertIsBoolean.isNonEmptyString(url)) return false;
+	let decodedUrl;
+	try {
+		decodedUrl = decodeURIComponent(url);
+	} catch {
+		return false;
+	}
+	if (!decodedUrl.startsWith("http://") && !decodedUrl.startsWith("https://")) return false;
+	//! DEPRECATED
+	return (/* @__PURE__ */ new RegExp(/^https?:\/\/(?:localhost(?::\d+)?(?:[\/?#][^\s]*)?|(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}(?::\d+)?(?:[\/?#][^\s]*)?)$/)).test(decodedUrl);
+};
+function isWeakMap(value) {
+	return require_assertIsBoolean.isObject(value) && !require_assertIsBoolean.isNull(value) && value instanceof WeakMap;
+}
+Object.defineProperty(exports, 'areArraysEqual', {
+  enumerable: true,
+  get: function () {
+    return areArraysEqual;
+  }
+});
+Object.defineProperty(exports, 'areObjectsEqual', {
+  enumerable: true,
+  get: function () {
+    return areObjectsEqual;
+  }
+});
+Object.defineProperty(exports, 'areURLsEqualPath', {
+  enumerable: true,
+  get: function () {
+    return areURLsEqualPath;
+  }
+});
+Object.defineProperty(exports, 'areURLsIdentical', {
+  enumerable: true,
+  get: function () {
+    return areURLsIdentical;
+  }
+});
+Object.defineProperty(exports, 'arrayHasAnyMatch', {
+  enumerable: true,
+  get: function () {
+    return arrayHasAnyMatch;
+  }
+});
+Object.defineProperty(exports, 'doesKeyExist', {
+  enumerable: true,
+  get: function () {
+    return doesKeyExist;
+  }
+});
+Object.defineProperty(exports, 'isArguments', {
+  enumerable: true,
+  get: function () {
+    return isArguments;
+  }
+});
+Object.defineProperty(exports, 'isArrayLike', {
+  enumerable: true,
+  get: function () {
+    return isArrayLike;
+  }
+});
+Object.defineProperty(exports, 'isArrayLikeObject', {
+  enumerable: true,
+  get: function () {
+    return isArrayLikeObject;
+  }
+});
+Object.defineProperty(exports, 'isCurrencyLike', {
+  enumerable: true,
+  get: function () {
+    return isCurrencyLike;
+  }
+});
+Object.defineProperty(exports, 'isDeepEqual', {
+  enumerable: true,
+  get: function () {
+    return isDeepEqual;
+  }
+});
+Object.defineProperty(exports, 'isElement', {
+  enumerable: true,
+  get: function () {
+    return isElement;
+  }
+});
+Object.defineProperty(exports, 'isEmpty', {
+  enumerable: true,
+  get: function () {
+    return isEmpty;
+  }
+});
+Object.defineProperty(exports, 'isEmptyDeep', {
+  enumerable: true,
+  get: function () {
+    return isEmptyDeep;
+  }
+});
+Object.defineProperty(exports, 'isEqualWith', {
+  enumerable: true,
+  get: function () {
+    return isEqualWith;
+  }
+});
+Object.defineProperty(exports, 'isLength', {
+  enumerable: true,
+  get: function () {
+    return isLength;
+  }
+});
+Object.defineProperty(exports, 'isMatch', {
+  enumerable: true,
+  get: function () {
+    return isMatch;
+  }
+});
+Object.defineProperty(exports, 'isMatchWith', {
+  enumerable: true,
+  get: function () {
+    return isMatchWith;
+  }
+});
+Object.defineProperty(exports, 'isNative', {
+  enumerable: true,
+  get: function () {
+    return isNative;
+  }
+});
+Object.defineProperty(exports, 'isObjectLoose', {
+  enumerable: true,
+  get: function () {
+    return isObjectLoose;
+  }
+});
+Object.defineProperty(exports, 'isPropertyKey', {
+  enumerable: true,
+  get: function () {
+    return isPropertyKey;
+  }
+});
+Object.defineProperty(exports, 'isSafeInteger', {
+  enumerable: true,
+  get: function () {
+    return isSafeInteger;
+  }
+});
+Object.defineProperty(exports, 'isValidURL', {
+  enumerable: true,
+  get: function () {
+    return isValidURL;
+  }
+});
+Object.defineProperty(exports, 'isWeakMap', {
+  enumerable: true,
+  get: function () {
+    return isWeakMap;
+  }
+});
+Object.defineProperty(exports, 'textContainsAll', {
+  enumerable: true,
+  get: function () {
+    return textContainsAll;
+  }
+});
+Object.defineProperty(exports, 'textContainsAny', {
+  enumerable: true,
+  get: function () {
+    return textContainsAny;
+  }
+});
+//# sourceMappingURL=predicates-DiaYA7Ps.cjs.map

package/dist/predicates-DiaYA7Ps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates-DiaYA7Ps.cjs","names":["isArray","getPreciseType","isEqual","safeStableStringify","isEqual","isURL","isURL","isNonEmptyString","isArray","isNonEmptyString","isArray","isObjectOrArray","getPreciseType","isArray","isArray","isEmptyArray","isFunction","isObjectOrArray","isObjectOrArray","isString","isNumber","parseCurrencyString","isDate","isRegExp","isSymbol","isSet","isMap","isArray","isObjectOrArray","isPlainObject","isNil","isBoolean","isNumber","isSymbol","isFunction","isString","isArray","isTypedArray","isMap","isSet","isBuffer","isPlainObject","isString","isEmptyString","isNumber","isNaN","isArray","isEmptyArray","isObjectOrArray","baseDeepEqual","isObjectOrArray","isArray","isUndefined","isFunction","isNil","isObjectOrArray","isFunction","isNonEmptyString","isObject","isNull"],"sources":["../src/predicates/are/areArraysEqual.ts","../src/predicates/are/areObjectsEqual.ts","../src/predicates/are/areURLsEqualPath.ts","../src/predicates/are/areURLsIdentical.ts","../src/predicates/contains/textContainsAll.ts","../src/predicates/contains/textContainsAny.ts","../src/predicates/is/isPropertyKey.ts","../src/predicates/exist/doesKeyExist.ts","../src/predicates/has/arrayHasAnyMatch.ts","../src/predicates/is/isArgument.ts","../src/predicates/is/isLength.ts","../src/predicates/is/isArrayLike.ts","../src/predicates/is/isArrayLikeObject.ts","../src/predicates/is/isCurrencyLike.ts","../src/predicates/is/isDeepEqual.ts","../src/predicates/is/isElement.ts","../src/predicates/is/isEmpty.ts","../src/predicates/is/isEmptyDeep.ts","../src/predicates/is/isEqualWith.ts","../src/predicates/is/isMatchWith.ts","../src/predicates/is/_private/baseIsMatch.ts","../src/predicates/is/isMatch.ts","../src/predicates/is/isNative.ts","../src/predicates/is/isObjectLoose.ts","../src/predicates/is/isSafeInteger.ts","../src/predicates/is/isValidURL.ts","../src/predicates/is/isWeakMap.ts"],"sourcesContent":["import { isArray } from \"../is/isArray\";\nimport { isEqual } from \"../is/isEqual\";\nimport { getPreciseType } from \"../type/getPreciseType\";\n\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `areArraysEqual`.***\n * ----------------------------------------------------------\n * **Compares two arrays deeply to check if they are equal.**\n * @description Supports deep comparison of arrays containing nested arrays or objects,\n *  can also ignore the order of elements at all levels by recursively sorting.\n * @param {unknown[]} array1\n *   ***The first array to compare, can contain nested arrays or objects.***\n * @param {unknown[]} array2\n *   ***The second array to compare against, should match structure of `array1`.***\n * @param {boolean|undefined} [ignoreOrder=false]\n *   ***Whether to ignore the order of elements when comparing.***\n *    - If `true`, will sort both arrays recursively before comparing, default is `false`.\n * @returns {boolean}\n *    Returns `true` if both arrays are deeply equal, otherwise `false`.\n * @throws **{@link TypeError | `TypeError`}** if `array1` or `array2` are not arrays, or if `ignoreOrder` is not a boolean.\n * @example\n * ```ts\n * areArraysEqual([1, 2, 3], [1, 2, 3]);\n * // ➔ true\n * areArraysEqual([1, 2, 3], [3, 2, 1]);\n * // ➔ false\n * areArraysEqual([1, 2, 3], [3, 2, 1], true);\n * // ➔ true (order ignored)\n * areArraysEqual([{ x: 1 }, { y: 2 }], [{ y: 2 }, { x: 1 }], true);\n * // ➔ true\n * ```\n */\nexport const areArraysEqual = (\n  array1: unknown[],\n  array2: unknown[],\n  ignoreOrder: boolean = false\n): boolean => {\n  if (!(isArray(array1) && isArray(array2))) {\n    throw new TypeError(\n      `Parameters \\`array1\\` and \\`array2\\` property of the \\`options\\` (second parameter) must be of type \\`array\\`, but received: ['array1': \\`${getPreciseType(\n        array1\n      )}\\`, 'array2': \\`${getPreciseType(array2)}\\`].`\n    );\n  }\n\n  assertIsBoolean(ignoreOrder, {\n    message: ({ currentType, validType }) =>\n      `Third parameter \\`ignoreOrder\\` must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (!isEqual(array1.length, array2.length)) return false;\n\n  /**\n   * Recursively sorts an array (and nested arrays) so that\n   * deep equality checks can ignore order at all levels.\n   *\n   * @param {unknown[]} arr - The array to deep sort.\n   * @returns {unknown[]} A new deeply sorted array.\n   */\n  const deepIgnoreOrder = (arr: unknown[]): unknown[] => {\n    if (!isArray(arr)) return arr;\n\n    // Recursively sort nested arrays\n    const sorted = arr.map((item) => {\n      if (isArray(item)) {\n        return deepIgnoreOrder(item);\n      }\n      return item;\n    });\n\n    // Sort current array level\n    return sorted.sort((a, b) => {\n      const sa = safeStableStringify(a);\n      const sb = safeStableStringify(b);\n      return sa < sb ? -1 : sa > sb ? 1 : 0;\n    });\n  };\n\n  const normalizedArr1 = ignoreOrder ? deepIgnoreOrder(array1) : array1;\n  const normalizedArr2 = ignoreOrder ? deepIgnoreOrder(array2) : array2;\n\n  if (!isEqual(normalizedArr1.length, normalizedArr2.length)) return false;\n\n  return normalizedArr1.every(\n    (item, index) =>\n      safeStableStringify(item) === safeStableStringify(normalizedArr2[index])\n  );\n};\n","import { isEqual } from \"../is/isEqual\";\n\n/** ---------------------------------\n * * ***Predicate: `areObjectsEqual`.***\n * ---------------------------------\n * **Compares two objects for deep equality.**\n * @template T1 The type of the first object.\n * @template T2 The type of the second object.\n * @param {*} object1 - The first object to compare.\n * @param {*} object2 - The second object to compare.\n * @returns {boolean} Return `true` if both objects are deeply equal, otherwise `false`.\n * @example\n * areObjectsEqual({ a: 1, b: 2 }, { a: 1, b: 2 });\n * // ➔ true\n * areObjectsEqual({ a: 1 }, { a: 1, b: undefined });\n * // ➔ false\n * areObjectsEqual([1, 2, 3], [1, 2, 3]);\n * // ➔ true\n */\nexport const areObjectsEqual = (\n  object1: unknown,\n  object2: unknown\n): boolean => {\n  return isEqual(object1, object2);\n};\n","import { isURL } from \"../is/isURL\";\n\n/** ---------------------------------\n * * ***Predicate: `areURLsEqualPath`.***\n * ---------------------------------\n * **Checks if two URLs are the same, ignoring query parameters, this function compares only the protocol, host, and pathname.**\n * @param {URL} urlA - The first URL to compare.\n * @param {URL} urlB - The second URL to compare.\n * @returns {boolean} Returns `true` if both URLs are the same (ignoring search parameters), otherwise `false`.\n * @example\n * // Same domain, same path, different query -> true\n * areURLsEqualPath(\n *   new URL(\"https://example.com/page?a=1\"),\n *   new URL(\"https://example.com/page?b=2\")\n * );\n * // ➔ true\n *\n * // Same domain, different path -> false\n * areURLsEqualPath(\n *   new URL(\"https://example.com/page1\"),\n *   new URL(\"https://example.com/page2\")\n * );\n * // ➔ false\n *\n * // Different protocol -> false\n * areURLsEqualPath(\n *   new URL(\"http://example.com/page\"),\n *   new URL(\"https://example.com/page\")\n * );\n * // ➔ false\n *\n * // Same protocol, same host, same path (ignores query & hash) -> true\n * areURLsEqualPath(\n *   new URL(\"https://example.com/page#section\"),\n *   new URL(\"https://example.com/page\")\n * );\n * // ➔ true\n */\nexport const areURLsEqualPath = (urlA: URL, urlB: URL): boolean => {\n  if (!isURL(urlA) || !isURL(urlB)) {\n    throw new TypeError(\n      \"Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.\"\n    );\n  }\n\n  return (\n    urlA.protocol + \"//\" + urlA.host + urlA.pathname ===\n    urlB.protocol + \"//\" + urlB.host + urlB.pathname\n  );\n};\n","import { isURL } from \"../is/isURL\";\n\n/** ---------------------------------\n * * ***Predicate: `areURLsIdentical`.***\n * ---------------------------------\n * **Checks if two URLs are exactly the same, including protocol, host, pathname, and query parameters.**\n * @param {URL} urlA - The first URL to compare.\n * @param {URL} urlB - The second URL to compare.\n * @returns {boolean} Returns `true` if both URLs are identical, otherwise `false`.\n * @example\n * // Identical URLs -> true\n * areURLsIdentical(\n *   new URL(\"https://example.com/page?a=1\"),\n *   new URL(\"https://example.com/page?a=1\")\n * );\n * // ➔ true\n *\n * // Same path, different query parameter -> false\n * areURLsIdentical(\n *   new URL(\"https://example.com/page?a=1\"),\n *   new URL(\"https://example.com/page?b=2\")\n * );\n * // ➔ false\n *\n * // Same host & query, but different protocol -> false\n * areURLsIdentical(\n *   new URL(\"http://example.com/page?a=1\"),\n *   new URL(\"https://example.com/page?a=1\")\n * );\n * // ➔ false\n *\n * // Same everything except trailing slash -> false\n * areURLsIdentical(\n *   new URL(\"https://example.com/page\"),\n *   new URL(\"https://example.com/page/\")\n * );\n * // ➔ false\n */\nexport const areURLsIdentical = (urlA: URL, urlB: URL): boolean => {\n  if (!isURL(urlA) || !isURL(urlB)) {\n    throw new TypeError(\n      \"Parameters `urlA` and `urlB` (first and second parameter) must be instance of URL.\"\n    );\n  }\n\n  return (\n    urlA.protocol + \"//\" + urlA.host + urlA.pathname + urlA.search ===\n    urlB.protocol + \"//\" + urlB.host + urlB.pathname + urlB.search\n  );\n};\n","import { isArray } from \"../is/isArray\";\nimport { isNonEmptyString } from \"../is/isNonEmptyString\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype OptionsTextContainsAll = {\n  /** If `true`, matches whole words only, defaultValue is `false`.\n   *\n   * @default false\n   */\n  exactMatch?: boolean;\n  /** Optional regex flags (default: `\"i\"` for case-insensitive).\n   *\n   * @default \"i\"\n   */\n  flags?: string;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `textContainsAll`.***\n * ----------------------------------------------------------\n * **Checks if the given `text` contains all of the specified `searchWords`.**\n * - **Behavior:**\n *    - Returns `false` if `text` or `searchWords` is `null`/`undefined`/invalid.\n *    - Uses **regular expressions** for flexible pattern matching.\n *    - **Escapes special characters** to prevent regex injection attacks.\n *    - **Trims input** to avoid false positives with empty spaces.\n *    - **Supports exact word matching** (optional).\n * @param {string|null|undefined} text - The string text to search within.\n * @param {string[]|null} [searchWords] - An array of words/phrases to match against the text.\n * @param {OptionsTextContainsAll} [options] - Optional configuration object.\n * @param {OptionsTextContainsAll[\"exactMatch\"]} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.\n * @param {OptionsTextContainsAll[\"flags\"]} [options.flags=\"i\"] - Optional regex flags (default: `\"i\"` for case-insensitive).\n * @returns {boolean} Return `true` if all `searchWords` are found in `text`, otherwise `false`.\n * @example\n * textContainsAll(\"Hello world, WithAI APP\", [\"Hello\", \"world\"]);\n * // ➔ true\n * textContainsAll(\"JavaScript and TypeScript\", [\"Java\", \"Script\"]);\n * // ➔ true\n * textContainsAll(\"Machine Learning\", [\"AI\", \"Learning\"]);\n * // ➔ false\n * textContainsAll(\"open-source\", [\"open\"], { exactMatch: true });\n * // ➔ false (because options `exactMatch=true`)\n * textContainsAll(null, [\"test\"]);\n * // ➔ false (invalid text)\n * textContainsAll(\"Hello\", null);\n * // ➔ false (invalid searchWords)\n */\nexport const textContainsAll = <T extends string>(\n  text?: T | null,\n  searchWords?: T[] | string[] | null,\n  options: OptionsTextContainsAll = {}\n): boolean => {\n  if (!isNonEmptyString(text) || !isArray(searchWords)) {\n    return false;\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // fallback to default\n  const { exactMatch = false, flags = \"i\" } = options;\n\n  assertIsBoolean(exactMatch, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`exactMatch\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsString(flags, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`flags\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n  // Escape special regex characters to prevent unintended behavior\n  const escapeRegex = (str: string) =>\n    str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n  // Filter out empty search words\n  const validSearchWords = searchWords\n    .filter((word) => isNonEmptyString(word))\n    .map(escapeRegex);\n\n  if (validSearchWords.length === 0) return false;\n\n  // Create regex pattern: Whole word match (`\\bword\\b`) <- is deprecated. if `exactMatch` is true\n  return validSearchWords.every((word) => {\n    const pattern = exactMatch ? `(?<!\\\\S)${word}(?!\\\\S)` : word;\n    return new RegExp(pattern, flags.includes(\"u\") ? flags : flags + \"u\").test(\n      text\n    );\n  });\n};\n","import { isArray } from \"../is/isArray\";\nimport { isNonEmptyString } from \"../is/isNonEmptyString\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype OptionsTextContainsAny = {\n  /** If `true`, matches whole words only, defaultValue is `false`.\n   *\n   * @default false\n   */\n  exactMatch?: boolean;\n  /** Optional regex flags (default: `\"i\"` for case-insensitive).\n   *\n   * @default \"i\"\n   */\n  flags?: string;\n};\n\n/** ----------------------------------------------------------\n * * ***Predicate: `textContainsAny`.***\n * ----------------------------------------------------------\n * **Checks if the given `text` contains at least one of the specified `searchWords`.**\n * - **Behavior:**\n *    - Returns `false` if `text` or `searchWords` is `null`/`undefined`/invalid.\n *    - Uses **regular expressions** for flexible pattern matching.\n *    - **Escapes special characters** to prevent regex injection attacks.\n *    - **Trims input** to avoid false positives with empty spaces.\n *    - **Supports exact word matching** (optional).\n * @param {string|null|undefined} text - The string text to search within.\n * @param {string[]|null} [searchWords] - An array of words/phrases to match against the text.\n * @param {OptionsTextContainsAny} [options] - Optional configuration object.\n * @param {OptionsTextContainsAny[\"exactMatch\"]} [options.exactMatch=false] - If `true`, matches whole words only, defaultValue is `false`.\n * @param {OptionsTextContainsAny[\"flags\"]} [options.flags=\"i\"] - Optional regex flags (default: `\"i\"` for case-insensitive).\n * @returns {boolean} Return `true` if at least one `searchWord` is found in `text`, otherwise `false`.\n * @example\n * textContainsAny(\"Hello world\", [\"hello\", \"test\"]);\n * // ➔ true\n * textContainsAny(\"withAI APP\", [\"chat\", \"ai\"]);\n * // ➔ false\n * textContainsAny(\"TypeScript is great!\", [\"script\", \"java\"]);\n * // ➔ true\n * textContainsAny(\"open-source\", [\"open\"], { exactMatch: true });\n * // ➔ false (because options `exactMatch=true`)\n * textContainsAny(null, [\"test\"]);\n * // ➔ false (invalid text)\n * textContainsAny(\"Hello\", null);\n * // ➔ false (invalid searchWords)\n */\nexport const textContainsAny = <T extends string>(\n  text?: T | null,\n  searchWords?: T[] | string[] | null,\n  options: OptionsTextContainsAny = {}\n): boolean => {\n  if (!isNonEmptyString(text) || !isArray(searchWords)) {\n    return false;\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // fallback to default\n  const { exactMatch = false, flags = \"i\" } = options;\n\n  assertIsBoolean(exactMatch, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`exactMatch\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsString(flags, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`flags\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  // Escape special regex characters to prevent unintended behavior\n  const escapeRegex = (str: string) =>\n    str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n\n  // Filter out empty search words\n  const validSearchWords = searchWords\n    .filter((word) => isNonEmptyString(word))\n    .map(escapeRegex);\n\n  if (validSearchWords.length === 0) return false;\n\n  const pattern = exactMatch\n    ? `(?<!\\\\S)(${validSearchWords.join(\"|\")})(?!\\\\S)`\n    : `(${validSearchWords.join(\"|\")})`;\n\n  return new RegExp(pattern, flags.includes(\"u\") ? flags : flags + \"u\").test(\n    text\n  );\n};\n","/** ----------------------------------------------------------\n * * ***Type guard: `PropertyKey`.***\n * ----------------------------------------------------------\n * **Checks if a value is a valid `PropertyKey`.**\n * - **In JavaScript/TypeScript, a **`PropertyKey`** is any of:**\n *    - **`string`**\n *    - **`number`**\n *    - **`symbol`**\n * - **This function ensures the given `value` is one of these types.**\n *    - Narrows type to {@link PropertyKey | ***`PropertyKey`***} when true.\n *    - Useful for working with dynamic object keys.\n *    - Strictly rejects `null`, `undefined`, `boolean`, `object`, `function`, etc.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if `value` is a valid property key, otherwise `false`.\n * @example\n * isPropertyKey(\"foo\");\n * // ➔ true\n * isPropertyKey(123);\n * // ➔ true\n * isPropertyKey(Symbol(\"id\"));\n * // ➔ true\n * isPropertyKey({});\n * // ➔ false\n * isPropertyKey(null);\n * // ➔ false\n */\nexport function isPropertyKey(value: unknown): value is PropertyKey {\n  const type = typeof value;\n  return type === \"string\" || type === \"number\" || type === \"symbol\";\n}\n","import { isArray } from \"../is/isArray\";\nimport { isPropertyKey } from \"../is/isPropertyKey\";\nimport { isObjectOrArray } from \"../is/isObjectOrArray\";\nimport { getPreciseType } from \"../type/getPreciseType\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `doesKeyExist`.***\n * ----------------------------------------------------------\n * **Recursively checks if a given key exists in an object or array.**\n * - **Behavior:**\n *    - **Supports deeply nested objects and arrays**, searching recursively.\n *    - Uses `Object.prototype.hasOwnProperty.call()` to safely check if the\n *      key exists at each level, even if its value is `null` or `undefined`.\n *    - Optimized to return `true` immediately when the key is found (short-circuits).\n *    - Handles edge cases gracefully:\n *      - Returns `false` for `null`, `undefined`, or non-object inputs.\n *      - Returns `false` if key is not found anywhere, even in deeply nested\n *        structures.\n * - **ℹ️ Note:**\n *    - This function only checks for **the existence of the key itself**,\n *      not whether its value is non-null or non-undefined.\n *    - If you need to check for both existence and meaningful value, write a stricter function.\n * @template T - The type of the input object or array.\n * @param {T | Record<string, unknown> | unknown[]} object - The object or array to search.\n * @param {PropertyKey} key - The key to look for (string, number, or symbol).\n * @returns {boolean} Returns `true` if the key exists anywhere in the object or array (even with `null` / `undefined` value), otherwise `false`.\n * @example\n * doesKeyExist({ name: \"John\", age: 30 }, \"age\");\n * // ➔ true\n * doesKeyExist({ user: { profile: { email: \"test@example.com\" } } }, \"email\");\n * // ➔ true\n * doesKeyExist([{ id: 1 }, { id: 2 }], \"id\");\n * // ➔ true\n * doesKeyExist({ a: { b: { c: 10 } } }, \"d\");\n * // ➔ false\n * doesKeyExist(null, \"name\");\n * // ➔ false\n * doesKeyExist(undefined, \"test\");\n * // ➔ false\n *\n * // Key exists even if value is null or undefined:\n * doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"a\"); // ➔ true\n * doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"b\"); // ➔ true\n * doesKeyExist({ a: null, b: undefined, c: { d: null } }, \"d\"); // ➔ true\n *\n * doesKeyExist({ a: 1 }, true);\n * // ➔ ❌ Throws TypeError\n * doesKeyExist({ a: 1 }, [\"not\", \"valid\"]);\n * // ➔ ❌ Throws TypeError\n */\nexport const doesKeyExist = (\n  object: Record<string, unknown> | unknown[],\n  key: PropertyKey\n): boolean => {\n  if (!isObjectOrArray(object)) return false; // Handle null, undefined, and non-objects\n\n  if (!isPropertyKey(key)) {\n    throw new TypeError(\n      `Second Parameter (\\`key\\`) must be of type \\`string\\`, \\`number\\` or \\`symbol\\`, but received: \\`${getPreciseType(\n        key\n      )}\\`.`\n    );\n  }\n\n  // Direct match found\n  if (Object.prototype.hasOwnProperty.call(object, key)) return true;\n\n  if (isArray(object)) {\n    // Check each array item recursively\n    return object.some((item) => doesKeyExist(item as unknown[], key));\n  }\n\n  return Object.values(object).some(\n    (value) => isObjectOrArray(value) && doesKeyExist(value, key)\n  );\n};\n","import { isArray } from \"../is/isArray\";\nimport { isEmptyArray } from \"../is/isEmptyArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `arrayHasAnyMatch`.***\n * ----------------------------------------------------------\n * **Checks if at least one element from `targetArray` exists in `sourceArray`.**\n * - **Behavior:**\n *    - Uses `Set` for **faster lookup** compared to `Array.prototype.includes()`.\n *    - Supports **any data type** (`number`, `string`, `boolean`, `object`, `array`, `function`, etc.).\n *    - Uses **reference equality** for non-primitive values (object, array, function).\n *    - Returns `false` if either array is missing, empty, or not an array.\n * @template T - The expected type of array elements.\n * @param {T[] | null | undefined} sourceArray - The array to search within.\n * @param {T[] | null | undefined} targetArray - The array containing elements to match.\n * @returns {boolean}\n *  ***Return:***\n *  - `true` if **at least one element from `targetArray` is strictly found\n *  in `sourceArray`**.\n *    - Comparison uses:\n *      - **Value equality** for primitives (`number`, `string`, `boolean`, `null`, `undefined`).\n *      - **Reference equality** for `objects`, `arrays`, and `functions`.\n *  - `false` if:\n *      - No matching elements exist,\n *      - Either array is not provided, not an actual array, or is empty.\n * @example\n * arrayHasAnyMatch([\"apple\", \"banana\", \"cherry\"], [\"banana\", \"grape\"]);\n * // ➔ true\n * arrayHasAnyMatch([\"red\", \"blue\"], [\"green\", \"yellow\"]);\n * // ➔ false\n * arrayHasAnyMatch([1, 2, 3], [3, 4, 5]);\n * // ➔ true\n * arrayHasAnyMatch([], [\"test\"]);\n * // ➔ false\n * arrayHasAnyMatch([\"A\", \"B\", \"C\"], []);\n * // ➔ false\n *\n * const obj = { x: 1 };\n * arrayHasAnyMatch([obj], [obj]);\n * // ➔ true (same reference)\n * arrayHasAnyMatch([{ x: 1 }], [{ x: 1 }]);\n * // ➔ false (different reference)\n *\n * const fn = () => \"hello\";\n * arrayHasAnyMatch([fn], [fn]);\n * // ➔ true\n * arrayHasAnyMatch([() => \"hello\"], [() => \"hello\"]);\n * // ➔ false (different function reference)\n *\n * const arr = [1, 2];\n * arrayHasAnyMatch([arr], [arr]);\n * // ➔ true\n * arrayHasAnyMatch([[1, 2]], [[1, 2]]);\n * // ➔ false (different array object)\n */\nexport const arrayHasAnyMatch = <T>(\n  sourceArray: T[] | null | undefined,\n  targetArray: T[] | null | undefined\n): boolean => {\n  if (\n    !isArray(sourceArray) ||\n    !isArray(targetArray) ||\n    isEmptyArray(sourceArray) ||\n    isEmptyArray(targetArray)\n  ) {\n    return false;\n  }\n\n  // use Set for lookup more faster.\n  const sourceSet = new Set(sourceArray);\n  return targetArray.some((item) => sourceSet.has(item));\n};\n","/** -------------------\n * * ***Type guard: `isArguments`.***\n * -------------------\n * **Checks if `value` is likely an `arguments` object.**\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an ***[`IArguments`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments)*** object, else `false`.\n * @example\n * isArguments(function() { return arguments; }());\n * // ➔ true\n * isArguments([1, 2, 3]);\n * // ➔ false\n */\nexport const isArguments = (value: unknown): value is IArguments => {\n  return Object.prototype.toString.call(value) === \"[object Arguments]\";\n};\n","/** ----------------------------------------\n * * ***Predicate: `isLength`.***\n * ----------------------------------------------------------\n * **Checks whether the given value is a **valid array-like length**.**\n * - **Behavior:**\n *    - ✅ Ensures the value is a **non-negative integer**.\n *    - ✅ Ensures the value is **not greater than `Number.MAX_SAFE_INTEGER`**.\n *    - ❌ Excludes non-numeric values, `Infinity`, and fractional numbers.\n * - **ℹ️ Note:**\n *    - This method is loosely based-on\n *      [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *    - A valid length must be a non-negative integer and **not greater\n *      than `Number.MAX_SAFE_INTEGER`**.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n * isLength(3);\n * // ➔ true\n * isLength(Number.MAX_SAFE_INTEGER);\n * // ➔ true\n * isLength(Number.MAX_SAFE_INTEGER + 1);\n * // ➔ false\n * isLength(\"3\");\n * // ➔ false\n * isLength(-1);\n * // ➔ false\n * isLength(3.14);\n * // ➔ false\n * isLength(Infinity);\n * // ➔ false\n * isLength(-Infinity);\n * // ➔ false\n * isLength(Number.MIN_VALUE);\n * // ➔ false\n */\nexport function isLength(value: unknown): boolean {\n  return (\n    typeof value === \"number\" &&\n    value > -1 &&\n    Number.isInteger(value) &&\n    value <= Number.MAX_SAFE_INTEGER\n  );\n}\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\n\nimport { isLength } from \"./isLength\";\nimport { isFunction } from \"./isFunction\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isArrayLike`.***\n * ----------------------------------------------------\n * **Checks if `value` is array-like, a value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.**\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n * isArrayLike([1, 2, 3]);\n * // ➔ true\n * isArrayLike(document.body.children);\n * // ➔ true\n * isArrayLike(noop);\n * // ➔ false\n * isArrayLike('abc');\n * // ➔ false\n */\nexport function isArrayLike<T extends { __anyHack: unknown }>(\n  value: T\n): boolean;\nexport function isArrayLike(\n  value: AnyFunction | null | undefined\n): value is never;\nexport function isArrayLike(value: unknown): value is { length: number };\nexport function isArrayLike(value: unknown) {\n  return (\n    !isFunction(value) && isObjectOrArray(value) && isLength(value?.length)\n  );\n}\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\nimport { isLength } from \"./isLength\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isArrayLikeObject`.***\n * ----------------------------------------------------\n * **This method is like ***`isArrayLike` utility function*** except that\n *   it also checks if `value` is an object.**\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `array-like object`, else `false`.\n * @example\n * isArrayLikeObject([1, 2, 3]);\n * // ➔ true\n * isArrayLikeObject(document.body.children);\n * // ➔ true\n * isArrayLikeObject('abc');\n * // ➔ false\n * isArrayLikeObject(noop);\n * // ➔ false\n */\nexport function isArrayLikeObject<T extends { __anyHack: unknown }>(\n  value: T\n): boolean;\nexport function isArrayLikeObject(\n  value: AnyFunction | string | boolean | number | null | undefined\n): value is never;\nexport function isArrayLikeObject(\n  value: unknown\n): value is object & { length: number };\nexport function isArrayLikeObject(value: unknown) {\n  return isObjectOrArray(value) && isLength(value.length);\n}\n","import { isNumber } from \"./isNumber\";\nimport { isString } from \"./isString\";\nimport { parseCurrencyString } from \"@/conversions/currency/parsing\";\n\n/** -----------------------------------------------------------\n * * ***Predicate: `isCurrencyLike`.***\n * -----------------------------------------------------------\n * **Determines if the given `input` can be interpreted as a currency-like number,\n * using the same **multi-locale parsing logic** as ***`parseCurrencyString`***.**\n * - **Highlights:**\n *    - *Supports strings or numbers like:*\n *      - `\"15.000,10\"` ***(European)***.\n *      - `\"15,000.10\"` ***(US)***.\n *      - `\"15'000.10\"` ***(Swiss)***.\n *      - `\"15 000,10\"` ***(French)***.\n *      - `\"Rp 15.000,10\"` or `\"$15,000.10\"`.\n *    - Also accepts simple numbers (`15300.95`).\n * - **ℹ️ Note:**\n *    - Uses the same core logic as\n *      ***`parseCurrencyString`*** but\n *      just checks if a final parsed float is sensible.\n * @param {*} input - The input value to check.\n * @returns {boolean} Return `true` if it can be reasonably parsed into a currency-like number, `false` otherwise.\n * @example\n * isCurrencyLike(15300.95);\n * // ➔ true\n * isCurrencyLike(\"$15,000.10\");\n * // ➔ true\n * isCurrencyLike(\"(15'000.10)\");\n * // ➔ true\n * isCurrencyLike(\"Rp 15.000,10\");\n * // ➔ true\n * isCurrencyLike(\"\");\n * // ➔ false\n * isCurrencyLike(\"abc\");\n * // ➔ false\n */\nexport const isCurrencyLike = (input: unknown): boolean => {\n  if (!(isString(input) || isNumber(input))) return false;\n\n  const parsed = parseCurrencyString(input.toString());\n  // If parseCurrencyString returns a meaningful number (not just fallback zero for empty/invalid input)\n  if (parsed !== 0) return true;\n\n  // Special case: if input was exactly \"0\", still valid\n  return input.toString().trim() === \"0\";\n};\n","import { isMap } from \"./isMap\";\nimport { isSet } from \"./isSet\";\nimport { isDate } from \"./isDate\";\nimport { isArray } from \"./isArray\";\nimport { isRegExp } from \"./isRegExp\";\nimport { isSymbol } from \"./isSymbol\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isDeepEqual`.***\n * ----------------------------------------------------------\n * **Performs a deep equality check between two values.**\n * - **Behavior:**\n *    - Compares nested `arrays`, `objects`, `Dates`, `RegExp`, `NaN`, `Symbols`,\n *      `Set`, and `Map`.\n *    - Handles special cases:\n *        - `NaN` is considered equal to `NaN`.\n *        - `Date` objects are equal if `.getTime()` is equal.\n *        - `RegExp` objects are equal if `.toString()` is equal.\n *        - `Symbol(\"x\")` and `Symbol(\"x\")` are treated equal if\n *          `.toString()` matches.\n *        - `Set` and `Map` are deeply compared by content (order-insensitive).\n * - **ℹ️ Note:**\n *    - Does not support circular references.\n * @param {*} a - First value to compare.\n * @param {*} b - Second value to compare.\n * @returns {boolean} `true` if both values are deeply equal, otherwise `false`.\n * @example\n * // ✅ Primitives\n * isDeepEqual(1, 1);\n * // ➔ true\n * isDeepEqual(NaN, NaN);\n * // ➔ true\n * isDeepEqual(\"hello\", \"world\");\n * // ➔ false\n *\n * // ✅ Objects\n * isDeepEqual({ x: 1 }, { x: 1 });\n * // ➔ true\n * isDeepEqual({ x: 1 }, { y: 1 });\n * // ➔ false\n *\n * // ✅ Arrays\n * isDeepEqual([1, 2], [1, 2]);\n * // ➔ true\n * isDeepEqual([1, 2], [2, 1]);\n * // ➔ false\n *\n * // ✅ Dates\n * isDeepEqual(new Date(123), new Date(123));\n * // ➔ true\n *\n * // ✅ Sets\n * isDeepEqual(new Set([1, 2]), new Set([2, 1]));\n * // ➔ true\n *\n * // ✅ Maps\n * isDeepEqual(new Map([[\"a\", 1]]), new Map([[\"a\", 1]]));\n * // ➔ true\n *\n * // ❌ Different types\n * isDeepEqual(1, \"1\");\n * // ➔ false\n */\nexport const isDeepEqual = (a: unknown, b: unknown): boolean => {\n  // Handle NaN\n  if (\n    typeof a === \"number\" &&\n    typeof b === \"number\" &&\n    Number.isNaN(a) &&\n    Number.isNaN(b)\n  ) {\n    return true;\n  }\n\n  // Primitive equality\n  if (a === b) return true;\n\n  // Type mismatch\n  if (typeof a !== typeof b) return false;\n\n  // Date\n  if (isDate(a) && isDate(b)) {\n    return a.getTime() === b.getTime();\n  }\n\n  // RegExp\n  if (isRegExp(a) && isRegExp(b)) {\n    return a.toString() === b.toString();\n  }\n\n  // Symbol\n  if (isSymbol(a) && isSymbol(b)) {\n    return a.toString() === b.toString();\n  }\n\n  // Set\n  if (isSet(a) && isSet(b)) {\n    if (a.size !== b.size) return false;\n    const bValues = Array.from(b);\n    const matched = new Set<number>();\n\n    for (const aVal of a) {\n      let found = false;\n      for (let i = 0; i < bValues.length; i++) {\n        if (matched.has(i)) continue;\n        if (isDeepEqual(aVal, bValues[i])) {\n          matched.add(i);\n          found = true;\n          break;\n        }\n      }\n      if (!found) return false;\n    }\n    return true;\n  }\n\n  // Map\n  if (isMap(a) && isMap(b)) {\n    if (a.size !== b.size) return false;\n    const bEntries = Array.from(b);\n    const matched = new Set<number>();\n\n    for (const [aKey, aVal] of a) {\n      let found = false;\n      for (let i = 0; i < bEntries.length; i++) {\n        if (matched.has(i)) continue;\n        const [bKey, bVal] = bEntries[i];\n        if (isDeepEqual(aKey, bKey) && isDeepEqual(aVal, bVal)) {\n          matched.add(i);\n          found = true;\n          break;\n        }\n      }\n      if (!found) return false;\n    }\n    return true;\n  }\n\n  // Array\n  if (isArray(a) && isArray(b)) {\n    if (a.length !== b.length) return false;\n    return a.every((item, i) => isDeepEqual(item, b[i]));\n  }\n\n  // Object\n  if (isObjectOrArray(a) && isObjectOrArray(b) && a && b) {\n    if (isArray(a) !== isArray(b)) return false;\n\n    const aKeys = Object.keys(a);\n    const bKeys = Object.keys(b);\n    if (aKeys.length !== bKeys.length) return false;\n\n    return aKeys.every((key) => isDeepEqual(a[key], b[key]));\n  }\n\n  return false;\n};\n","import { isPlainObject } from \"./isPlainObject\";\n\n/** ----------------------------------------------------\n * * ***Type guard: `isElement`.***\n * ----------------------------------------------------------\n * **Checks if `value` is likely a\n *   **[`DOM Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element)**.**\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is extends instance of **[`Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element)**, else `false`.\n * @example\n * isElement(document.body);\n * // ➔ true\n * isElement(document.createElement(\"div\"));\n * // ➔ true\n * isElement('<body>');\n * // ➔ false\n * isElement(document);\n * // ➔ false\n * isElement({ tagName: \"DIV\" });\n * // ➔ false\n */\nexport function isElement(value: []): value is [];\nexport function isElement<T extends Element>(value: T): value is T;\nexport function isElement(value: unknown): value is Element;\nexport function isElement(value: unknown) {\n  return (\n    !!value &&\n    typeof value === \"object\" &&\n    (value as Element)?.nodeType === 1 &&\n    !isPlainObject(value)\n  );\n  // return typeof Element === \"function\" && value instanceof Element;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { List, EmptyObjectOf } from \"./_private/types.isEmpty\";\n\nimport { isNil } from \"./isNil\";\nimport { isMap } from \"./isMap\";\nimport { isSet } from \"./isSet\";\nimport { isArray } from \"./isArray\";\nimport { isBuffer } from \"./isBuffer\";\nimport { isNumber } from \"./isNumber\";\nimport { isSymbol } from \"./isSymbol\";\nimport { isString } from \"./isString\";\nimport { isBoolean } from \"./isBoolean\";\nimport { isFunction } from \"./isFunction\";\nimport { isArguments } from \"./isArgument\";\nimport { isTypedArray } from \"./isTypedArray\";\nimport { isPlainObject } from \"./isPlainObject\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isEmpty`.***\n * ----------------------------------------------------------\n * **Checks if `value` is an empty object, collection, map, or set.**\n * - **Behavior:**\n *    - **Objects** are empty if they have no own enumerable string keyed properties.\n *    - **Array-like values** (arrays, strings, `arguments`, typed arrays, buffers)\n *      are empty if their `length` is `0`.\n *    - **Maps** and **Sets** are empty if their `size` is `0`.\n *    - **Booleans**, **numbers** (including `NaN`), **symbols**, and `null`/\n *      `undefined` are treated as empty.\n *    - **Functions** are considered empty if they have no own enumerable keys.\n * - **ℹ️ Note:**\n *    - For more `Strict`, you can use\n *      ***`isEmptyValue` utility function*** instead.\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n * @example\n * isEmpty(null);\n * // ➔ true\n * isEmpty(true);\n * // ➔ true\n * isEmpty(false);\n * // ➔ true\n * isEmpty(1);\n * // ➔ true\n * isEmpty(0);\n * // ➔ true\n * isEmpty(Symbol(\"x\"));\n * // ➔ true\n * isEmpty(() => {});\n * // ➔ true\n * isEmpty(\"\");\n * // ➔ true\n * isEmpty(\"   \");\n * // ➔ false\n * isEmpty([1, 2, 3]);\n * // ➔ false\n * isEmpty({ 'a': 1 });\n * // ➔ false\n */\nexport function isEmpty<T extends { __trapAny: any }>(value?: T): boolean;\nexport function isEmpty(value: string): value is \"\";\nexport function isEmpty(\n  value: Map<any, any> | Set<any> | List<any> | null | undefined\n): boolean;\nexport function isEmpty(value: object): boolean;\nexport function isEmpty<T extends object>(\n  value: T | null | undefined\n): value is EmptyObjectOf<T> | null | undefined;\nexport function isEmpty(value: any): boolean;\nexport function isEmpty(value: unknown) {\n  // null / undefined\n  if (isNil(value)) return true;\n\n  // Boolean, number, symbol\n  if (\n    isBoolean(value) ||\n    isNumber(value, { includeNaN: true }) ||\n    isSymbol(value)\n  )\n    return true;\n\n  // Function ➔ treat like object: check own enumerable keys\n  if (isFunction(value)) {\n    return Object.keys(value).length === 0;\n  }\n\n  // String / Array-like\n  if (\n    isString(value) ||\n    isArray(value) ||\n    isArguments(value) ||\n    isTypedArray(value)\n  ) {\n    return value.length === 0;\n  }\n\n  // Map / Set\n  if (isMap(value) || isSet(value)) {\n    return value.size === 0;\n  }\n\n  // Buffer\n  if (isBuffer(value)) {\n    return value.length === 0;\n  }\n\n  // Object (check own enumerable keys)\n  if (isPlainObject(value)) {\n    return Object.keys(value).length === 0;\n  }\n\n  return false;\n}\n","import { isNaN } from \"./isNaN\";\nimport { isArray } from \"./isArray\";\nimport { isString } from \"./isString\";\nimport { isNumber } from \"./isNumber\";\nimport { isEmptyArray } from \"./isEmptyArray\";\nimport { isEmptyString } from \"./isEmptyString\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------------\n * * ***Predicate: `isEmptyDeep`.***\n * ----------------------------------------------------------\n * **Recursively checks whether a value is **deeply empty**.**\n * - **Returns `true` for:**\n *    - Empty objects: `{}`\n *    - Empty arrays: `[]`\n *    - Nested empty structures: `{ a: [], b: {} }`\n *    - Falsy values (except numbers): `null`, `undefined`, `false`, `\"\"`, `NaN`\n * - **Returns `false` for:**\n *    - Non-zero numbers\n *    - Objects or arrays containing non-empty values\n *    - Non-empty strings, `true`, functions, symbols, etc.\n * @param {*} value - The value to deeply check.\n * @returns {boolean} `true` if the value is deeply empty, otherwise `false`.\n * @example\n * isEmptyDeep({});\n * // ➔ true\n * isEmptyDeep([]);\n * // ➔ true\n * isEmptyDeep({ a: {} });\n * // ➔ true\n * isEmptyDeep([[], {}]);\n * // ➔ true\n * isEmptyDeep({ a: [1] });\n * // ➔ false\n * isEmptyDeep([0]);\n * // ➔ false\n * isEmptyDeep(\"test\");\n * // ➔ false\n * isEmptyDeep(\"\");\n * // ➔ true\n * isEmptyDeep(0);\n * // ➔ false\n * isEmptyDeep(NaN);\n * // ➔ true\n */\nexport const isEmptyDeep = (value: unknown): boolean => {\n  if (isString(value)) return isEmptyString(value);\n  // Number ➔ only NaN counts as empty\n  if (isNumber(value)) return isNaN(value);\n  if (isArray(value)) {\n    return isEmptyArray(value) || value.every(isEmptyDeep);\n  }\n  if (isObjectOrArray(value)) {\n    const keys = Object.keys(value);\n    const symbols = Object.getOwnPropertySymbols(value);\n    // return (\n    //   [...keys, ...symbols].length === 0 ||\n    //   [...keys, ...symbols].every((key) =>\n    //     isObject(value) && isString(key) ? isEmptyDeep(value[key]) : key\n    //   )\n    // );\n\n    if (keys.length === 0 && symbols.length === 0) return true;\n\n    return [...keys, ...symbols].every((key) => isEmptyDeep(value[key]));\n  }\n  if (!value) return true;\n\n  return false;\n};\n","import type { CustomizerIsEqualWith } from \"./_private/types.isEqualWith\";\nimport { baseDeepEqual } from \"@/predicates/is/_private/baseDeepEqual\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isEqualWith`.***\n * ----------------------------------------------------\n * **Performs a deep comparison between two values with support for a\n * customizer function.**\n * @description\n * This method is like ***`isEqual` utility function*** except that it\n * accepts a `customizer` which is invoked to compare values.\n * - **Behavior:**\n *     - If `customizer` returns `undefined`, the comparison is handled by\n *       the default deep equality algorithm.\n *     - The `customizer` is invoked with up to six arguments:\n *       - `(value, other, indexOrKey, parent, otherParent, stack)`,\n *         see **{@link CustomizerIsEqualWith | `CustomizerIsEqualWith`}**.\n *     - Supports comparing `arrays`, `objects`, `maps`, `sets`, `dates`,\n *       `regexes`, `typed arrays`, `etc`.\n *     - Functions and DOM nodes are **not** supported.\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {CustomizerIsEqualWith} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n * function isGreeting(value: unknown) {\n *   return typeof value === \"string\" && /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue: unknown, othValue: unknown) {\n *   if (isGreeting(objValue) && isGreeting(othValue)) {\n *     return true;\n *   }\n * }\n *\n * const array = [\"hello\", \"goodbye\"];\n * const other = [\"hi\", \"goodbye\"];\n *\n * isEqualWith(array, other, customizer);\n * // ➔ true\n */\nexport function isEqualWith(\n  value: unknown,\n  other: unknown,\n  customizer?: CustomizerIsEqualWith\n): boolean {\n  return baseDeepEqual(value, other, customizer, new WeakMap());\n}\n","import type { CustomizerIsMatchWith } from \"./_private/types.isMatchWith\";\nimport { baseIsMatch } from \"@/predicates/is/_private/baseIsMatch\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isMatchWith`.***\n * ----------------------------------------------------\n * **Performs a partial deep comparison between `object` and `source`, like `isMatch`, but with a `customizer` function to control comparisons.**\n * @description\n * If `customizer` returns a value other than `undefined`, that value is used\n * as the result of the comparison for the current property. Otherwise,\n * the comparison falls back to the default deep equality logic.\n * - **Behavior:**\n *    - The `customizer` function is invoked with up to **five** arguments:\n *        - `(objValue, srcValue, keyOrIndex, object, source)`,\n *        see **{@link CustomizerIsMatchWith | `CustomizerIsMatchWith`}**.\n *    - Returning `true` from `customizer` will short-circuit further comparison\n *      for that key.\n *    - Returning `false` will cause `isMatchWith` to return `false` immediately.\n *    - Returning `undefined` allows default comparison to proceed.\n * @param {object} value - The object to inspect.\n * @param {object} other - The object of property values to match.\n * @param {CustomizerIsMatchWith} [customizer] - The function to customize comparisons.\n * @returns Returns `true` if `object` is a match, else `false`.\n * @example\n * function isGreeting(value: unknown) {\n *   return typeof value === 'string' && /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue: unknown, srcValue: unknown) {\n *   if (isGreeting(objValue) && isGreeting(srcValue)) {\n *     return true;\n *   }\n * }\n *\n * const object = { greeting: 'hello' };\n * const source = { greeting: 'hi' };\n *\n * isMatchWith(object, source, customizer);\n * // ➔ true\n */\nexport function isMatchWith(\n  value: object,\n  other: object,\n  customizer?: CustomizerIsMatchWith\n): boolean {\n  return baseIsMatch(value, other, customizer);\n}\n","import type { CustomizerIsMatchWith } from \"./types.isMatchWith\";\n\nimport { isArray } from \"../isArray\";\nimport { isUndefined } from \"../isUndefined\";\nimport { isMatchWith } from \"../isMatchWith\";\nimport { isObjectOrArray } from \"../isObjectOrArray\";\n\n// #Private - local\nfunction isSameValue(x: unknown, y: unknown): boolean {\n  return (\n    x === y || (x === 0 && y === 0) || (Number.isNaN(x) && Number.isNaN(y))\n  );\n}\n\n/** -------------------------------------------------------------------\n * * ***Base function (**Internal**) for matching objects with optional customizer.***\n * -------------------------------------------------------------------\n * **Recursively checks whether `object` matches `source`. Supports custom comparison\n * via `customizer`, and handles arrays, objects, and nested structures.**\n * @param object\n * - The object to test against the `source`.\n * @param source\n * - The source object to match.\n * @param customizer\n * - Optional function to customize the comparison for each property/value.\n * @returns\n * - `true`  → `object` matches `source`.\n * - `false` → `object` does not match `source`.\n * @example\n * ```ts\n * const obj = { name: \"Alice\", age: 30 };\n * const src = { name: \"alice\" };\n * const customizer: CustomizerIsMatchWith = (value, other) => {\n *   if (typeof value === \"string\" && typeof other === \"string\") {\n *     return value.toLowerCase() === other.toLowerCase();\n *   }\n * };\n *\n * baseIsMatch(obj, src, customizer);\n * // returns true\n * ```\n */\nexport function baseIsMatch(\n  object: unknown,\n  source: unknown,\n  customizer?: CustomizerIsMatchWith\n): boolean {\n  if (object === source) return true;\n\n  if (!isObjectOrArray(source)) {\n    return isSameValue(object, source);\n  }\n\n  if (!isObjectOrArray(object)) {\n    return false;\n  }\n\n  const keys = Reflect.ownKeys(source).filter(\n    (k) => !(isArray(source) && k === \"length\")\n  );\n\n  for (const key of keys) {\n    if (!(key in object)) return false;\n\n    const objValue = object[key];\n    const srcValue = source[key];\n\n    const result = customizer?.(objValue, srcValue, key, object, source);\n    if (!isUndefined(result)) {\n      if (!result) return false;\n      continue; // skip default comparison\n    }\n\n    if (isObjectOrArray(objValue) && isObjectOrArray(srcValue)) {\n      if (!isMatchWith(objValue, srcValue, customizer)) return false;\n    } else {\n      if (!isSameValue(objValue, srcValue)) return false;\n    }\n  }\n\n  return true;\n}\n","import { baseIsMatch } from \"@/predicates/is/_private/baseIsMatch\";\n\n/** ----------------------------------------------------\n * * ***Predicate: `isMatch`.***\n * ----------------------------------------------------\n * **Performs a partial deep comparison between `object` and `source`.**\n * @description\n * Determines whether `object` contains equivalent property values from `source`.\n * - **Behavior:**\n *    - ✅ Returns `true` if **all properties** in `source` exist in `object` and are deeply equal.\n *    - ❌ Does **not** require `object` and `source` to be the same shape—`object` may have extra properties.\n *    - ⚠️ Arrays are treated as objects: only matching indexed keys are compared.\n * - **Remarks:**\n *    - This is functionally equivalent to a partially applied `matches(source)` predicate.\n *    - Special cases:\n *      - An empty array (`[]`) in `source` matches any array in `object`.\n *      - An empty object (`{}`) in `source` matches any object in `object`.\n * @param {object} object - The object to inspect.\n * @param {object} source - The object containing property values to match.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n * @example\n * const object = { a: 1, b: 2 };\n *\n * isMatch(object, { b: 2 });\n * // ➔ true\n * isMatch(object, { b: 1 });\n * // ➔ false\n * isMatch([1, 2, 3], [1, 2]);\n * // ➔ true (treats arrays as objects with index keys)\n */\nexport function isMatch(object: object, source: object): boolean {\n  return baseIsMatch(object, source);\n}\n","import type { AnyFunction } from \"@rzl-zone/ts-types-plus\";\nimport { isFunction } from \"./isFunction\";\n\nconst funcToString = Function.prototype.toString;\nconst reIsNative = /\\{\\s*\\[native code\\]\\s*\\}/;\n\n/** ----------------------------------------------------\n * * ***Type guard: `isNative`.***\n * ----------------------------------------------------------\n * **Checks if a value is a **pristine native function**.**\n * - **ℹ️ Note:**\n *    - This method may not reliably detect native functions when using packages\n *      like `core-js`, as they override native behavior.\n *    - Attempts to detect native functions in such environments may fail or\n *      throw errors.\n *    - This also affects packages like\n *      **[`babel-polyfill`](https://www.npmjs.com/package/babel-polyfill).**\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function, else `false`.\n * @example\n * isNative(Array.prototype.push);\n * // ➔ true\n *\n * import * as RzlUtilsJs from \"@rzl-zone/utils-js/predicates\";\n * isNative(RzlUtilsJs);\n * // ➔ false\n */\nexport function isNative(value: unknown): value is AnyFunction {\n  if (!isFunction(value)) return false;\n\n  try {\n    const source = funcToString.call(value);\n    return reIsNative.test(source);\n  } catch {\n    return false;\n  }\n}\n","import { isNil } from \"./isNil\";\nimport { isFunction } from \"./isFunction\";\nimport { isObjectOrArray } from \"./isObjectOrArray\";\n\n/** ----------------------------------------------------------\n * * ***Type guard: `isObjectLoose`.***\n * ----------------------------------------------------------\n * **Checks if a value is the\n * [ECMAScript language type ***Object***](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types).**\n * - **✅ Returns `true` for:**\n *    - Plain objects (`{}`)\n *    - Arrays (`[]`)\n *    - Functions\n *    - Regexes (`/abc/`)\n *    - Boxed primitives:\n *      - `new Number(0)`\n *      - `new String(\"\")`\n *      - `new Boolean(false)`\n * - **❌ Returns `false` for:**\n *    - `null`\n *    - `undefined`\n *    - Primitives:\n *      - `string`\n *      - `number`\n *      - `boolean`\n *      - `symbol`\n *      - `bigint`\n * - **ℹ️ Note:**\n *    - **For More Strict Object Use ***`isObject`*** or ***`isPlainObject` utility function*** instead.**\n * @template T - The type of the value being checked.\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n * isObjectLoose({});\n * // ➔ true\n * isObjectLoose([1, 2, 3]);\n * // ➔ true\n * isObjectLoose(()=> {});\n * // ➔ true\n * isObjectLoose(null);\n * // ➔ false\n * isObjectLoose(undefined);\n * // ➔ false\n */\nexport function isObjectLoose<T = object>(value: unknown): value is T {\n  return !isNil(value) && (isObjectOrArray(value) || isFunction(value));\n}\n","/** --------------------------------------------------\n * * ***Type guard: `isSafeInteger`.***\n * --------------------------------------------------\n * **Checks if `value` is a **[`Safe-Integer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger)**.**\n * - **Behavior:**\n *    - Narrows type to `number` when true.\n * - **An integer is considered *safe* if:**\n *    - It is an `IEEE-754` **double precision number**.\n *    - It can be exactly represented without rounding errors.\n *    - It lies within the range **-(2^53 - 1) to 2^53 - 1**.\n * - **Note:**\n *    - This method is based on **{@link Number.isSafeInteger | `Number.isSafeInteger`}**.\n * @param {*} value - The value to check.\n * @returns {boolean} Return `true` if `value` is a safe integer, otherwise `false`.\n * @example\n * isSafeInteger(3);\n * // ➔ true\n * isSafeInteger(Number.MIN_VALUE);\n * // ➔ false\n * isSafeInteger(Infinity);\n * // ➔ false\n * isSafeInteger('3');\n * // ➔ false\n */\nexport function isSafeInteger(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isSafeInteger(value);\n}\n","import { isNonEmptyString } from \"./isNonEmptyString\";\n\n/** ---------------------------------------------------------\n * * ***Predicate: `isValidURL`.***\n * ---------------------------------------------------------\n * **Validates whether a given string is a properly formatted URL.**\n * - **Ensures that the input is:**\n *    - A non-empty string.\n *    - A valid **[`URL`](https://developer.mozilla.org/docs/Web/API/URL)** with `http://` or `https://` scheme.\n * - **Behavior:**\n *    - ✅ Includes decoding for percent-encoded URLs (e.g., `https%3A%2F%2F...`).\n *    - ❌ Rejects invalid strings, unsupported schemes, and malformed domains.\n * @param {*} url - The value to validate.\n * @returns {boolean} Return `true` if the value is a **valid URL string**, otherwise `false`.\n * @example\n * isValidURL(\"https://example.com\");\n * // ➔ true\n * isValidURL(\"ftp://example.com\");\n * // ➔ false\n * isValidURL(\"not-a-url\");\n * // ➔ false\n */\nexport const isValidURL = (url: unknown): boolean => {\n  if (!isNonEmptyString(url)) return false;\n\n  // Attempt to decode the entire URL, including domain and query parameters\n  let decodedUrl: string;\n\n  try {\n    // Decode the URL (to handle cases like https%3A%2F%2F becoming https://)\n    decodedUrl = decodeURIComponent(url);\n  } catch {\n    // If decoding fails, return false as it indicates an invalid encoded URL\n    return false;\n  }\n\n  // Check if the decoded URL starts with http:// or https://\n  if (!decodedUrl.startsWith(\"http://\") && !decodedUrl.startsWith(\"https://\")) {\n    return false;\n  }\n\n  // the original more extra\n  const urlPattern = new RegExp(\n    // eslint-disable-next-line no-useless-escape\n    /^https?:\\/\\/(?:localhost(?::\\d+)?(?:[\\/?#][^\\s]*)?|(?:www\\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}(?::\\d+)?(?:[\\/?#][^\\s]*)?)$/\n\n    //! DEPRECATED\n    // /^https?:\\/\\/(?:localhost(?::\\d+)?(?:[/?#][^\\s]*)?|(?:www\\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6})(?:[/?#][^\\s]*)?$/\n    // /^https?:\\/\\/(?:www\\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b(?:[-a-zA-Z0-9()@:%_+.~#?&/=]*)$/\n  );\n\n  // Test the decoded URL against the regex pattern\n  return urlPattern.test(decodedUrl);\n};\n","import { isNull } from \"./isNull\";\nimport { isObject } from \"./isObject\";\n\n/** --------------------------------------------------\n * * ***Type guard: `isWeakMap`.***\n * ----------------------------------------------------------\n * **Checks if a value is a **[`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/WeakMap)** object.**\n * - **Behavior:**\n *    - Narrows type to `WeakMap<K, V>` when true.\n *    - Excludes `Map`, `arrays`, `plain-objects,` and `other non-WeakMap values`.\n * @template K - Keys must be objects.\n * @template V - Type of values stored in the WeakMap.\n * @param {*} value - The value to check.\n * @returns {boolean} Returns `true` if the value is a `WeakMap`, otherwise `false`.\n * @example\n * isWeakMap(new WeakMap);\n * // ➔ true\n * isWeakMap(new Map);\n * // ➔ false\n */\nexport function isWeakMap<K extends object = object, V = unknown>(\n  value: unknown\n): value is WeakMap<K, V> {\n  return isObject(value) && !isNull(value) && value instanceof WeakMap;\n}\n"],"mappings":"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"}