@oscarpalmer/atoms 0.154.0 → 0.156.0

package/dist/array/difference.js

@@ -0,0 +1,5 @@
+import { COMPARE_SETS_DIFFERENCE, compareSets } from "../internal/array/sets.js";
+function difference(first, second, key) {
+	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);
+}
+export { difference };

package/dist/array/exists.js

@@ -1,6 +1,6 @@
-import { findValue } from "../internal/array/find.js";
+import { FIND_VALUE_INDEX, findValue } from "../internal/array/find.js";
 function exists(array, ...parameters) {
 	if (parameters.length === 1 && typeof parameters[0] !== "function") return Array.isArray(array) ? array.includes(parameters[0]) : false;
-	return findValue("index", array, parameters) > -1;
+	return findValue(FIND_VALUE_INDEX, array, parameters) > -1;
 }
 export { exists };

package/dist/array/find.js

@@ -1,5 +1,5 @@
-import { findValue } from "../internal/array/find.js";
+import { FIND_VALUE_VALUE, findValue } from "../internal/array/find.js";
 function find(array, ...parameters) {
-	return findValue("value", array, parameters);
+	return findValue(FIND_VALUE_VALUE, array, parameters);
 }
 export { find };

package/dist/array/index-of.js

@@ -1,5 +1,5 @@
-import { findValue } from "../internal/array/find.js";
+import { FIND_VALUE_INDEX, findValue } from "../internal/array/find.js";
 function indexOf(array, ...parameters) {
-	return findValue("index", array, parameters);
+	return findValue(FIND_VALUE_INDEX, array, parameters);
 }
 export { indexOf };

package/dist/array/{misc.js → index.js}

@@ -1,3 +1,4 @@
+import { difference } from "./difference.js";
 import { exists } from "./exists.js";
 import { filter } from "./filter.js";
 import { find } from "./find.js";
@@ -6,9 +7,10 @@ import { range, times } from "./from.js";
 import { getArray } from "./get.js";
 import { indexOf } from "./index-of.js";
 import { chunk } from "../internal/array/chunk.js";
-import { insert } from "./insert.js";
 import { compact } from "../internal/array/compact.js";
 import { shuffle } from "../internal/array/shuffle.js";
+import { insert } from "./insert.js";
+import { intersection } from "./intersection.js";
 import { partition } from "./partition.js";
 import { push } from "./push.js";
 import { select } from "./select.js";
@@ -16,5 +18,6 @@ import { sort } from "./sort.js";
 import { splice } from "./splice.js";
 import { toSet } from "./to-set.js";
 import { toggle } from "./toggle.js";
+import { union } from "./union.js";
 import { update } from "./update.js";
-export { chunk, compact, exists, filter, find, flatten, getArray, indexOf, insert, partition, push, range, select, shuffle, sort, splice, times, toSet, toggle, update };
+export { chunk, compact, difference, exists, filter, find, flatten, getArray, indexOf, insert, intersection, partition, push, range, select, shuffle, sort, splice, times, toSet, toggle, union, update };

package/dist/array/intersection.js

@@ -0,0 +1,5 @@
+import { COMPARE_SETS_INTERSECTION, compareSets } from "../internal/array/sets.js";
+function intersection(first, second, key) {
+	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);
+}
+export { intersection };

package/dist/array/union.js

@@ -0,0 +1,5 @@
+import { COMPARE_SETS_UNION, compareSets } from "../internal/array/sets.js";
+function union(first, second, key) {
+	return compareSets(COMPARE_SETS_UNION, first, second, key);
+}
+export { union };

package/dist/array/unique.js

@@ -1,6 +1,6 @@
-import { findValues } from "../internal/array/find.js";
+import { FIND_VALUES_UNIQUE, findValues } from "../internal/array/find.js";
 function unique(array, key) {
 	if (!Array.isArray(array)) return [];
-	return array.length > 1 ? findValues("unique", array, [key, void 0]).matched : array;
+	return array.length > 1 ? findValues(FIND_VALUES_UNIQUE, array, [key, void 0]).matched : array;
 }
 export { unique };

package/dist/atoms.full.js

@@ -86,6 +86,15 @@ function isConstructor(value) {
 	return typeof value === "function" && value.prototype?.constructor === value;
 }
 /**
+* Is the value an instance of the constructor?
+* @param constructor Class constructor
+* @param value Value to check
+* @returns `true` if the value is an instance of the constructor, otherwise `false`
+*/
+function isInstanceOf(constructor, value) {
+	return isConstructor(constructor) && value instanceof constructor;
+}
+/**
 * Is the value a key?
 * @param value Value to check
 * @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
@@ -175,6 +184,37 @@ function shuffle(array) {
 	}
 	return shuffled;
 }
+function compareSets(type, first, second, key) {
+	if (!Array.isArray(first)) return [];
+	const isDifference = type === COMPARE_SETS_DIFFERENCE;
+	const isIntersection = type === COMPARE_SETS_INTERSECTION;
+	const isUnion = type === COMPARE_SETS_UNION;
+	if (first.length === 0) return isDifference ? [...first] : isIntersection ? [] : [...second];
+	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : [...first];
+	const callback = getArrayCallback(key);
+	const values = isUnion ? first : second;
+	let { length } = values;
+	const set = /* @__PURE__ */ new Set([]);
+	for (let index = 0; index < length; index += 1) {
+		const item = values[index];
+		set.add(callback?.(item, index, values) ?? item);
+	}
+	const source = isUnion ? second : first;
+	length = source.length;
+	const result = isUnion ? [...first] : [];
+	for (let index = 0; index < length; index += 1) {
+		const item = source[index];
+		const value = callback?.(item, index, source) ?? item;
+		if (isIntersection ? set.has(value) : !set.has(value)) result.push(item);
+	}
+	return result;
+}
+const COMPARE_SETS_DIFFERENCE = "difference";
+const COMPARE_SETS_INTERSECTION = "intersection";
+const COMPARE_SETS_UNION = "union";
+function difference(first, second, key) {
+	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);
+}
 function findValue(type, array, parameters) {
 	const findIndex = type === "index";
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
@@ -204,12 +244,12 @@ function findValues(type, array, parameters, mapper) {
 	const { length } = array;
 	const { bool, key, value } = getParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === FIND_VALUES_UNIQUE && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
 	const mapCallback = typeof mapper === "function" ? mapper : void 0;
-	if (callbacks?.bool != null || type === "all" && key == null) {
+	if (callbacks?.bool != null || type === FIND_VALUES_ALL && key == null) {
 		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
 		for (let index = 0; index < length; index += 1) {
 			const item = array[index];
@@ -222,7 +262,7 @@ function findValues(type, array, parameters, mapper) {
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
 		const keyed = callbacks?.keyed?.(item, index, array) ?? item;
-		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+		if (type === FIND_VALUES_ALL && Object.is(keyed, value) || type === FIND_VALUES_UNIQUE && !keys.has(keyed)) {
 			keys.add(keyed);
 			result.matched.push(mapCallback?.(item, index, array) ?? item);
 		} else result.notMatched.push(item);
@@ -237,20 +277,24 @@ function getParameters(original) {
 		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
 	};
 }
+const FIND_VALUE_INDEX = "index";
+const FIND_VALUE_VALUE = "value";
+const FIND_VALUES_ALL = "all";
+const FIND_VALUES_UNIQUE = "unique";
 const UNIQUE_THRESHOLD = 100;
 function exists(array, ...parameters) {
 	if (parameters.length === 1 && typeof parameters[0] !== "function") return Array.isArray(array) ? array.includes(parameters[0]) : false;
-	return findValue("index", array, parameters) > -1;
+	return findValue(FIND_VALUE_INDEX, array, parameters) > -1;
 }
 function filter(array, ...parameters) {
-	return findValues("all", array, parameters).matched;
+	return findValues(FIND_VALUES_ALL, array, parameters).matched;
 }
 filter.remove = removeFiltered;
 function removeFiltered(array, ...parameters) {
-	return findValues("all", array, parameters).notMatched;
+	return findValues(FIND_VALUES_ALL, array, parameters).notMatched;
 }
 function find(array, ...parameters) {
-	return findValue("value", array, parameters);
+	return findValue(FIND_VALUE_VALUE, array, parameters);
 }
 /**
 * Flatten an array _(using native `flat` and maximum depth)_
@@ -292,7 +336,7 @@ function getArray(value, indiced) {
 	return array;
 }
 function indexOf(array, ...parameters) {
-	return findValue("index", array, parameters);
+	return findValue(FIND_VALUE_INDEX, array, parameters);
 }
 function insertChunkedValues(type, array, items, start, deleteCount) {
 	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
@@ -318,8 +362,11 @@ function insertValues(type, array, items, start, deleteCount) {
 function insert(array, indexOrItems, items) {
 	return insertValues("insert", array, items == null ? indexOrItems : items, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);
 }
+function intersection(first, second, key) {
+	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);
+}
 function partition(array, ...parameters) {
-	const { matched, notMatched } = findValues("all", array, parameters);
+	const { matched, notMatched } = findValues(FIND_VALUES_ALL, array, parameters);
 	return [matched, notMatched];
 }
 /**
@@ -332,7 +379,7 @@ function push(array, pushed) {
 	return insertValues("push", array, pushed, array.length, 0);
 }
 function select(array, ...parameters) {
-	return findValues("all", array, parameters, parameters.pop()).matched;
+	return findValues(FIND_VALUES_ALL, array, parameters, parameters.pop()).matched;
 }
 function aggregate(type, array, key) {
 	const length = Array.isArray(array) ? array.length : 0;
@@ -639,6 +686,9 @@ function updateInArray(array, items, key, replace) {
 function toggle(array, values, key) {
 	return updateInArray(array, values, key, false);
 }
+function union(first, second, key) {
+	return compareSets(COMPARE_SETS_UNION, first, second, key);
+}
 function update(array, values, key) {
 	return updateInArray(array, values, key, true);
 }
@@ -675,7 +725,7 @@ function toRecordArrays(array, first, second) {
 }
 function unique(array, key) {
 	if (!Array.isArray(array)) return [];
-	return array.length > 1 ? findValues("unique", array, [key, void 0]).matched : array;
+	return array.length > 1 ? findValues(FIND_VALUES_UNIQUE, array, [key, void 0]).matched : array;
 }
 function getInterval(value) {
 	return typeof value === "number" && value > 0 ? value : 0;
@@ -1036,24 +1086,64 @@ function isOk(value) {
 function isResult(value) {
 	return _isResult(value, true) || _isResult(value, false);
 }
+/**
+* Asserts that a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+*/
 function assert(condition, message, error) {
 	if (!condition()) throw new (error ?? Error)(message);
 }
-assert.condition = (condition, message, error) => {
+assert.condition = assertCondition;
+assert.defined = assertDefined;
+assert.instanceOf = assertInstanceOf;
+assert.is = assertIs;
+/**
+* Creates an asserter that asserts a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertCondition(condition, message, error) {
 	return (value) => {
 		assert(() => condition(value), message, error);
 	};
-};
-assert.instanceOf = (constructor, message, error) => {
+}
+/**
+* Asserts that a value is defined throwing an error if it is not
+* @param value Value to assert
+* @param message Error message
+*/
+function assertDefined(value, message) {
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
+}
+/**
+* Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
+* @param constructor Constructor to check against
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertInstanceOf(constructor, message, error) {
 	return (value) => {
 		assert(() => value instanceof constructor, message, error);
 	};
-};
-assert.is = (condition, message, error) => {
+}
+/**
+* Creates an asserter that asserts a value is of a specific type, throwing an error if it is not
+* @param condition Type guard function to check the value
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertIs(condition, message, error) {
 	return (value) => {
 		assert(() => condition(value), message, error);
 	};
-};
+}
+const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 function asyncFlow(...fns) {
 	assertFlowFunctions(fns);
 	return (...args) => asyncWork(args.map((value) => {
@@ -1284,6 +1374,27 @@ function findKey(needle, haystack) {
 	const index = keys.map((key) => key.toLowerCase()).indexOf(needle.toLowerCase());
 	return index > -1 ? keys[index] : needle;
 }
+function getNestedValue(data, path, ignoreCase) {
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return {
+		exists: false,
+		value: void 0
+	};
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
+	const { length } = paths;
+	let current = data;
+	for (let index = 0; index < length; index += 1) {
+		const part = paths[index];
+		const handled = handleValue(current, part, null, true, shouldIgnoreCase);
+		if (!handled.exists) return handled;
+		current = handled.value;
+	}
+	return {
+		exists: true,
+		value: current
+	};
+}
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
 	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
@@ -1292,23 +1403,29 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return data[key];
+		if (get) return {
+			exists: key in data,
+			value: data[key]
+		};
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
+	if (get) return {
+		exists: false,
+		value: void 0
+	};
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
 const EXPRESSION_NESTED = /\.|\[\w+\]/;
 function getValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return;
-	const shouldIgnoreCase = ignoreCase === true;
-	const paths = getPaths(path, shouldIgnoreCase);
-	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
-	const { length } = paths;
-	let index = 0;
-	let value = data;
-	while (index < length && value != null) value = handleValue(value, paths[index++], null, true, shouldIgnoreCase);
-	return value;
+	return getNestedValue(data, path, ignoreCase === true).value;
+}
+function hasValue(data, path, ignoreCase) {
+	return getNestedValue(data, path, ignoreCase === true).exists;
+}
+hasValue.get = getWithHasValue;
+function getWithHasValue(data, path, ignoreCase) {
+	return getNestedValue(data, path, ignoreCase === true);
 }
 function setValue(data, path, value, ignoreCase) {
 	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
@@ -1327,7 +1444,7 @@ function setValue(data, path, value, ignoreCase) {
 			handleValue(target, currentPath, value, false, shouldIgnoreCase);
 			break;
 		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase);
+		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
 			if (EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number.parseInt(nextPath, 10) + 1 }, () => void 0);
@@ -1451,45 +1568,6 @@ const REPLACEMENT_CAMEL_CASE = "$1-$2";
 let memoizedCapitalize;
 let memoizedTitleCase;
 /**
-* Check if a string ends with a specified substring
-* @param haystack String to look in
-* @param needle String to look for
-* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
-* @returns `true` if the string ends with the given substring, otherwise `false`
-*/
-function endsWith(haystack, needle, ignoreCase) {
-	return match("endsWith", haystack, needle, ignoreCase === true);
-}
-/**
-* Check if a string includes a specified substring
-* @param haystack String to look in
-* @param needle String to look for
-* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
-* @returns `true` if the string includes the given substring, otherwise `false`
-*/
-function includes(haystack, needle, ignoreCase) {
-	return match("includes", haystack, needle, ignoreCase === true);
-}
-function match(type, haystack, needle, ignoreCase) {
-	if (typeof haystack !== "string" || typeof needle !== "string") return false;
-	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
-	return matchMemoizers[type].run(haystack, needle, ignoreCase);
-}
-function matchCallback(haystack, needle, ignoreCase) {
-	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
-}
-/**
-* Check if a string starts with a specified substring
-* @param haystack String to look in
-* @param needle String to look for
-* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
-* @returns `true` if the string starts with the given substring, otherwise `false`
-*/
-function startsWith(haystack, needle, ignoreCase) {
-	return match("startsWith", haystack, needle, ignoreCase === true);
-}
-const matchMemoizers = {};
-/**
 * Get a new UUID-string _(version 4)_
 * @returns UUID string
 */
@@ -1544,6 +1622,45 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
+/**
+* Check if a string ends with a specified substring
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string ends with the given substring, otherwise `false`
+*/
+function endsWith(haystack, needle, ignoreCase) {
+	return match("endsWith", haystack, needle, ignoreCase === true);
+}
+/**
+* Check if a string includes a specified substring
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string includes the given substring, otherwise `false`
+*/
+function includes(haystack, needle, ignoreCase) {
+	return match("includes", haystack, needle, ignoreCase === true);
+}
+function match(type, haystack, needle, ignoreCase) {
+	if (typeof haystack !== "string" || typeof needle !== "string") return false;
+	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
+	return matchMemoizers[type].run(haystack, needle, ignoreCase);
+}
+function matchCallback(haystack, needle, ignoreCase) {
+	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
+}
+/**
+* Check if a string starts with a specified substring
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string starts with the given substring, otherwise `false`
+*/
+function startsWith(haystack, needle, ignoreCase) {
+	return match("startsWith", haystack, needle, ignoreCase === true);
+}
+const matchMemoizers = {};
 function getTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -1800,68 +1917,6 @@ function setChanges(parameters) {
 	const diffsLength = diffs.length;
 	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
 }
-function getMergeOptions(options) {
-	const actual = {
-		replaceableObjects: void 0,
-		skipNullableAny: false,
-		skipNullableInArrays: false
-	};
-	if (typeof options !== "object" || options == null) return actual;
-	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
-	actual.skipNullableAny = options.skipNullableAny === true;
-	actual.skipNullableInArrays = options.skipNullableInArrays === true;
-	return actual;
-}
-function getReplaceableObjects(value) {
-	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
-	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
-}
-function handleMerge(values, options) {
-	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
-}
-/**
-* Merge multiple arrays or objects into a single one
-* @param values Values to merge
-* @param options Merging options
-* @returns Merged value
-*/
-function merge(values, options) {
-	return handleMerge(values, getMergeOptions(options));
-}
-merge.initialize = initializeMerger;
-/**
-* Create a merger with predefined options
-* @param options Merging options
-* @returns Merger function
-*/
-function initializeMerger(options) {
-	const actual = getMergeOptions(options);
-	return (values) => handleMerge(values, actual);
-}
-function mergeObjects(values, options, prefix) {
-	const { length } = values;
-	const isArray = values.every(Array.isArray);
-	const merged = isArray ? [] : {};
-	for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
-		const item = values[outerIndex];
-		const keys = Object.keys(item);
-		const size = keys.length;
-		for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
-			const key = keys[innerIndex];
-			const full = join([prefix, key], ".");
-			const next = item[key];
-			const previous = merged[key];
-			if (next == null && (options.skipNullableAny || isArray && options.skipNullableInArrays)) continue;
-			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) merged[key] = mergeValues([previous, next], options, false, full);
-			else merged[key] = next;
-		}
-	}
-	return merged;
-}
-function mergeValues(values, options, validate, prefix) {
-	const actual = validate ? values.filter(isArrayOrPlainObject) : values;
-	return actual.length > 1 ? mergeObjects(actual, options, prefix) : actual[0] ?? {};
-}
 function partial(value, providedKeys, omit) {
 	if (typeof value !== "object" || value === null) return {};
 	const keys = omit ? Object.keys(value) : Array.isArray(providedKeys) ? providedKeys : [];
@@ -1958,6 +2013,62 @@ function unsmush(value) {
 	}
 	return unsmushed;
 }
+function getMergeOptions(options) {
+	const actual = {
+		replaceableObjects: void 0,
+		skipNullableAny: false,
+		skipNullableInArrays: false
+	};
+	if (typeof options !== "object" || options == null) return actual;
+	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
+	actual.skipNullableAny = options.skipNullableAny === true;
+	actual.skipNullableInArrays = options.skipNullableInArrays === true;
+	return actual;
+}
+function getReplaceableObjects(value) {
+	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
+	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
+}
+function handleMerge(values, options) {
+	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
+}
+function merge(values, options) {
+	return handleMerge(values, getMergeOptions(options));
+}
+merge.initialize = initializeMerger;
+/**
+* Create a merger with predefined options
+* @param options Merging options
+* @returns Merger function
+*/
+function initializeMerger(options) {
+	const actual = getMergeOptions(options);
+	return (values) => handleMerge(values, actual);
+}
+function mergeObjects(values, options, prefix) {
+	const { length } = values;
+	const isArray = values.every(Array.isArray);
+	const merged = isArray ? [] : {};
+	for (let outerIndex = 0; outerIndex < length; outerIndex += 1) {
+		const item = values[outerIndex];
+		const keys = Object.keys(item);
+		const size = keys.length;
+		for (let innerIndex = 0; innerIndex < size; innerIndex += 1) {
+			const key = keys[innerIndex];
+			const full = join([prefix, key], ".");
+			const next = item[key];
+			const previous = merged[key];
+			if (next == null && (options.skipNullableAny || isArray && options.skipNullableInArrays)) continue;
+			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) merged[key] = mergeValues([previous, next], options, false, full);
+			else merged[key] = next;
+		}
+	}
+	return merged;
+}
+function mergeValues(values, options, validate, prefix) {
+	const actual = validate ? values.filter(isArrayOrPlainObject) : values;
+	return actual.length > 1 ? mergeObjects(actual, options, prefix) : actual[0] ?? {};
+}
 var Beacon = class {
 	#options;
 	#state;
@@ -2796,15 +2907,6 @@ function isEmpty(value) {
 	return true;
 }
 /**
-* Is the value an instance of the constructor?
-* @param constructor Class constructor
-* @param value Value to check
-* @returns `true` if the value is an instance of the constructor, otherwise `false`
-*/
-function isInstanceOf(constructor, value) {
-	return isConstructor(constructor) && value instanceof constructor;
-}
-/**
 * Is the value not `undefined` or `null`?
 * @param value Value to check
 * @returns `true` if the value is not `undefined` or `null`, otherwise `false`
@@ -3010,12 +3112,12 @@ function floor(value, decimals) {
 function median(array, key) {
 	let length = Array.isArray(array) ? array.length : 0;
 	if (!Array.isArray(array) || length === 0) return NaN;
-	if (length === 1) return isNumber(array[0]) ? array[0] : NaN;
 	let values = array;
 	const callback = getAggregateCallback(key);
 	if (callback != null) values = array.map((item, index) => callback(item, index, array));
 	const numbers = values.filter(isNumber).sort((first, second) => first - second);
 	length = numbers.length;
+	if (length === 1) return numbers[0];
 	if (length % 2 === 0) {
 		const first = length / 2 - 1;
 		const second = length / 2;
@@ -3772,4 +3874,4 @@ var SizedSet = class extends Set {
 		}
 	}
 };
-export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };