@oscarpalmer/atoms 0.137.0 → 0.139.0

package/dist/atoms.full.js

@@ -1823,6 +1823,167 @@ function throttle(callback, time) {
 	return getLimiter(callback, true, time);
 }
 const DEFAULT_CACHE_SIZE = 1024;
+function equal(first, second, options) {
+	return equalValue(first, second, getEqualOptions(options));
+}
+function equalArray(first, second, options) {
+	const { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= ARRAY_THRESHOLD) {
+		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
+		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
+		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
+	}
+	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const chunksLength = firstChunks.length;
+	for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
+		const firstChunk = firstChunks[chunkIndex];
+		const secondChunk = secondChunks[chunkIndex];
+		const chunkLength = firstChunk.length;
+		for (let index = 0; index < chunkLength; index += 1) if (!equalValue(firstChunk[index], secondChunk[index], options)) return false;
+	}
+	return true;
+}
+function equalArrayBuffer(first, second, options) {
+	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
+}
+function equalDataView(first, second, options) {
+	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
+}
+function equalMap(first, second, options) {
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstKeys = [...first.keys()];
+	const secondKeys = [...second.keys()];
+	if (firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	for (let index = 0; index < size; index += 1) {
+		const key = firstKeys[index];
+		if (!equalValue(first.get(key), second.get(key), options)) return false;
+	}
+	return true;
+}
+function equalPlainObject(first, second, options) {
+	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
+	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
+	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
+		firstKeys = firstKeys.filter((key) => filterKey(key, options));
+		secondKeys = secondKeys.filter((key) => filterKey(key, options));
+	}
+	const { length } = firstKeys;
+	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	for (let index = 0; index < length; index += 1) {
+		const key = firstKeys[index];
+		if (!equalValue(first[key], second[key], options)) return false;
+	}
+	return true;
+}
+function equalProperties(first, second, properties, options) {
+	const { length } = properties;
+	for (let index = 0; index < length; index += 1) {
+		const property = properties[index];
+		if (!equalValue(first[property], second[property], options)) return false;
+	}
+	return true;
+}
+function equalSet(first, second, options) {
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstValues = [...first];
+	const secondValues = [...second];
+	for (let index = 0; index < size; index += 1) {
+		const firstValue = firstValues[index];
+		if (!secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
+	}
+	return true;
+}
+function equalTypedArray(first, second) {
+	if (first.constructor !== second.constructor) return false;
+	if (first.byteLength !== second.byteLength) return false;
+	const { length } = first;
+	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
+	return true;
+}
+function equalValue(first, second, options) {
+	if (options.relaxedNullish && first == null && second == null) return true;
+	switch (true) {
+		case Object.is(first, second): return true;
+		case first == null || second == null: return first === second;
+		case typeof first !== typeof second: return false;
+		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
+		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
+		case first instanceof Date && second instanceof Date: return Object.is(Number(first), Number(second));
+		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
+		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ["name", "message"], options);
+		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
+		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, ["source", "flags"], options);
+		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
+		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
+		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
+		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
+		default: return equalHandlers.handle(first, second, options);
+	}
+}
+/**
+* Create an equalizer with predefined options
+* @param options Comparison options
+* @returns Equalizer function
+*/
+function initializeEqualizer(options) {
+	const actual = getEqualOptions(options);
+	return (first, second) => equalValue(first, second, actual);
+}
+/**
+* Register a equality comparison function for a specific class
+* @param constructor Class constructor
+* @param fn Comparison function
+*/
+function registerEqualizer(constructor, fn) {
+	equalHandlers.register(constructor, fn);
+}
+/**
+* Unregister a equality comparison handler for a specific class
+* @param constructor Class constructor
+*/
+function unregisterEqualizer(constructor) {
+	equalHandlers.unregister(constructor);
+}
+function filterKey(key, options) {
+	if (typeof key !== "string") return true;
+	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
+	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
+	return true;
+}
+function getEqualOptions(input) {
+	const options = {
+		ignoreCase: false,
+		ignoreExpressions: {
+			enabled: false,
+			values: []
+		},
+		ignoreKeys: {
+			enabled: false,
+			values: /* @__PURE__ */ new Set()
+		},
+		relaxedNullish: false
+	};
+	if (typeof input === "boolean") {
+		options.ignoreCase = input;
+		return options;
+	}
+	if (!isPlainObject(input)) return options;
+	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
+	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
+	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
+	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
+	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
+	options.relaxedNullish = input.relaxedNullish === true;
+	return options;
+}
+const equalHandlers = getCompareHandlers(equal, { callback: Object.is });
+const ARRAY_PEEK_PERCENTAGE = 10;
+const ARRAY_THRESHOLD = 100;
 var Logger = class {
 	/**
 	* Log any number of values at the "debug" log level
@@ -2118,45 +2279,160 @@ const MESSAGE_EXPECTATION = "Timed function expected a Promise";
 const MESSAGE_TIMEOUT = "Promise timed out";
 const TYPE_FULFILLED = "fulfilled";
 const TYPE_REJECTED = "rejected";
-var Queue = class {
-	#callback;
-	#handled = [];
-	#id = 0;
-	#items = [];
-	#options;
-	#paused;
-	#runners = 0;
-	/**
-	* Is the queue active?
-	*/
-	get active() {
-		return this.#runners > 0;
-	}
-	/**
-	* Does the queue automatically start when the first item is added?
-	*/
-	get autostart() {
-		return this.#options.autostart;
+function findKey(needle, haystack) {
+	const keys = Object.keys(haystack);
+	const index = keys.map((key) => key.toLowerCase()).indexOf(needle.toLowerCase());
+	return index > -1 ? keys[index] : needle;
+}
+function getPaths(path, lowercase) {
+	const normalized = lowercase ? path.toLowerCase() : path;
+	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
+}
+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];
+		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	/**
-	* Maximum number of runners to process the queue concurrently
-	*/
-	get concurrency() {
-		return this.#options.concurrency;
+}
+const EXPRESSION_BRACKET = /\[(\w+)\]/g;
+const EXPRESSION_DOTS = /^\.|\.$/g;
+const EXPRESSION_NESTED = /\.|\[\w+\]/;
+function setValue(data, path, value, ignoreCase) {
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") {
+		handleValue(data, paths, value, false, shouldIgnoreCase);
+		return data;
 	}
-	/**
-	* Is the queue empty?
-	*/
-	get empty() {
-		return this.#items.length === 0;
+	const { length } = paths;
+	const lastIndex = length - 1;
+	let target = data;
+	for (let index = 0; index < length; index += 1) {
+		const currentPath = paths[index];
+		if (index === lastIndex) {
+			handleValue(target, currentPath, value, false, shouldIgnoreCase);
+			break;
+		}
+		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase);
+		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);
+			else next = {};
+			target[currentPath] = next;
+		}
+		target = next;
 	}
-	/**
-	* Is the queue full?
-	*/
-	get full() {
-		return this.#options.maximum > 0 && this.#items.length >= this.#options.maximum;
+	return data;
+}
+const EXPRESSION_INDEX = /^\d+$/;
+/**
+* Convert a query string to a plain _(nested)_ object
+* @param query Query string to convert
+* @returns Plain object representation of the query string
+*/
+function fromQuery(query) {
+	if (typeof query !== "string" || query.trim().length === 0) return {};
+	const parts = query.split("&");
+	const { length } = parts;
+	const parameters = {};
+	for (let index = 0; index < length; index += 1) {
+		const decoded = parts[index].split("=").map(tryDecode);
+		const key = decoded[0].replace(EXPRESSION_ARRAY_SUFFIX, "");
+		if (!ignoreKey(key)) setQueryValue(parameters, key, decoded[1]);
 	}
-	/**
+	return parameters;
+}
+function getParts(value, fromArray, prefix) {
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const parts = [];
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const val = value[key];
+		const full = join([prefix, fromArray ? void 0 : key], ".");
+		if (Array.isArray(val)) parts.push(...getParts(val, true, full));
+		else if (isPlainObject(val)) parts.push(...getParts(val, false, full));
+		else if (isDecodable(val)) parts.push(`${tryEncode(full)}=${tryEncode(val)}`);
+		else if (val instanceof Date) parts.push(`${tryEncode(full)}=${val.toJSON()}`);
+	}
+	return parts;
+}
+function getQueryValue(value) {
+	if (EXPRESSION_BOOLEAN.test(value)) return value === "true";
+	const asNumber = getNumber(value);
+	if (!Number.isNaN(asNumber)) return asNumber;
+	const parsed = Date.parse(value);
+	if (Number.isNaN(parsed)) return value;
+	const date = new Date(parsed);
+	return date.toJSON() === value ? date : value;
+}
+function isDecodable(value) {
+	return TYPES.has(typeof value);
+}
+function setQueryValue(parameters, key, value) {
+	if (key.includes(".")) setValue(parameters, key, getQueryValue(value));
+	else if (key in parameters) {
+		if (!Array.isArray(parameters[key])) parameters[key] = [parameters[key]];
+		parameters[key].push(getQueryValue(value));
+	} else parameters[key] = getQueryValue(value);
+}
+/**
+* Convert a plain _(nested)_ object to a query string
+* @param parameters Plain object to convert
+* @returns Query string representation of the object
+*/
+function toQuery(parameters) {
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), "&") : "";
+}
+const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
+const EXPRESSION_BOOLEAN = /^(false|true)$/;
+const TYPES = new Set([
+	"boolean",
+	"number",
+	"string"
+]);
+var Queue = class {
+	#callback;
+	#handled = [];
+	#id = 0;
+	#items = [];
+	#options;
+	#paused;
+	#runners = 0;
+	/**
+	* Is the queue active?
+	*/
+	get active() {
+		return this.#runners > 0;
+	}
+	/**
+	* Does the queue automatically start when the first item is added?
+	*/
+	get autostart() {
+		return this.#options.autostart;
+	}
+	/**
+	* Maximum number of runners to process the queue concurrently
+	*/
+	get concurrency() {
+		return this.#options.concurrency;
+	}
+	/**
+	* Is the queue empty?
+	*/
+	get empty() {
+		return this.#items.length === 0;
+	}
+	/**
+	* Is the queue full?
+	*/
+	get full() {
+		return this.#options.maximum > 0 && this.#items.length >= this.#options.maximum;
+	}
+	/**
 	* Maximum number of items allowed in the queue
 	*/
 	get maximum() {
@@ -2325,121 +2601,6 @@ const MESSAGE_CALLBACK = "A Queue requires a callback function";
 const MESSAGE_CLEAR = "Queue was cleared";
 const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
 const MESSAGE_REMOVE = "Item removed from queue";
-function findKey(needle, haystack) {
-	const keys = Object.keys(haystack);
-	const index = keys.map((key) => key.toLowerCase()).indexOf(needle.toLowerCase());
-	return index > -1 ? keys[index] : needle;
-}
-function getPaths(path, lowercase) {
-	const normalized = lowercase ? path.toLowerCase() : path;
-	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
-	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
-}
-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];
-		data[key] = typeof value === "function" ? value(data[key]) : value;
-	}
-}
-const EXPRESSION_BRACKET = /\[(\w+)\]/g;
-const EXPRESSION_DOTS = /^\.|\.$/g;
-const EXPRESSION_NESTED = /\.|\[\w+\]/;
-function setValue(data, path, value, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
-	const shouldIgnoreCase = ignoreCase === true;
-	const paths = getPaths(path, shouldIgnoreCase);
-	if (typeof paths === "string") {
-		handleValue(data, paths, value, false, shouldIgnoreCase);
-		return data;
-	}
-	const { length } = paths;
-	const lastIndex = length - 1;
-	let target = data;
-	for (let index = 0; index < length; index += 1) {
-		const currentPath = paths[index];
-		if (index === lastIndex) {
-			handleValue(target, currentPath, value, false, shouldIgnoreCase);
-			break;
-		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase);
-		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);
-			else next = {};
-			target[currentPath] = next;
-		}
-		target = next;
-	}
-	return data;
-}
-const EXPRESSION_INDEX = /^\d+$/;
-/**
-* Convert a query string to a plain _(nested)_ object
-* @param query Query string to convert
-* @returns Plain object representation of the query string
-*/
-function fromQuery(query) {
-	if (typeof query !== "string" || query.trim().length === 0) return {};
-	const parts = query.split("&");
-	const { length } = parts;
-	const parameters = {};
-	for (let index = 0; index < length; index += 1) {
-		const decoded = parts[index].split("=").map(tryDecode);
-		const key = decoded[0].replace(EXPRESSION_ARRAY_SUFFIX, "");
-		if (!ignoreKey(key)) setQueryValue(parameters, key, decoded[1]);
-	}
-	return parameters;
-}
-function getParts(value, fromArray, prefix) {
-	const keys = Object.keys(value);
-	const { length } = keys;
-	const parts = [];
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const val = value[key];
-		const full = join([prefix, fromArray ? void 0 : key], ".");
-		if (Array.isArray(val)) parts.push(...getParts(val, true, full));
-		else if (isPlainObject(val)) parts.push(...getParts(val, false, full));
-		else if (isDecodable(val)) parts.push(`${tryEncode(full)}=${tryEncode(val)}`);
-		else if (val instanceof Date) parts.push(`${tryEncode(full)}=${val.toJSON()}`);
-	}
-	return parts;
-}
-function getQueryValue(value) {
-	if (EXPRESSION_BOOLEAN.test(value)) return value === "true";
-	const asNumber = getNumber(value);
-	if (!Number.isNaN(asNumber)) return asNumber;
-	const parsed = Date.parse(value);
-	if (Number.isNaN(parsed)) return value;
-	const date = new Date(parsed);
-	return date.toJSON() === value ? date : value;
-}
-function isDecodable(value) {
-	return TYPES.has(typeof value);
-}
-function setQueryValue(parameters, key, value) {
-	if (key.includes(".")) setValue(parameters, key, getQueryValue(value));
-	else if (key in parameters) {
-		if (!Array.isArray(parameters[key])) parameters[key] = [parameters[key]];
-		parameters[key].push(getQueryValue(value));
-	} else parameters[key] = getQueryValue(value);
-}
-/**
-* Convert a plain _(nested)_ object to a query string
-* @param parameters Plain object to convert
-* @returns Query string representation of the object
-*/
-function toQuery(parameters) {
-	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), "&") : "";
-}
-const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
-const EXPRESSION_BOOLEAN = /^(false|true)$/;
-const TYPES = new Set([
-	"boolean",
-	"number",
-	"string"
-]);
 /**
 * Get a random boolean
 * @return Random boolean
@@ -2814,169 +2975,23 @@ function template(value, variables, options) {
 	return handleTemplate(value, pattern, ignoreCase, variables);
 }
 const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
-function equal(first, second, options) {
-	return equalValue(first, second, getEqualOptions(options));
-}
-function equalArray(first, second, options) {
-	const { length } = first;
-	if (length !== second.length) return false;
-	let offset = 0;
-	if (length >= ARRAY_THRESHOLD) {
-		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
-		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
-		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
-	}
-	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
-	const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
-	const chunksLength = firstChunks.length;
-	for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
-		const firstChunk = firstChunks[chunkIndex];
-		const secondChunk = secondChunks[chunkIndex];
-		const chunkLength = firstChunk.length;
-		for (let index = 0; index < chunkLength; index += 1) if (!equalValue(firstChunk[index], secondChunk[index], options)) return false;
-	}
-	return true;
-}
-function equalArrayBuffer(first, second, options) {
-	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
-}
-function equalDataView(first, second, options) {
-	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
-}
-function equalMap(first, second, options) {
-	const { size } = first;
-	if (size !== second.size) return false;
-	const firstKeys = [...first.keys()];
-	const secondKeys = [...second.keys()];
-	if (firstKeys.some((key) => !secondKeys.includes(key))) return false;
-	for (let index = 0; index < size; index += 1) {
-		const key = firstKeys[index];
-		if (!equalValue(first.get(key), second.get(key), options)) return false;
-	}
-	return true;
-}
-function equalPlainObject(first, second, options) {
-	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
-	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
-	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
-		firstKeys = firstKeys.filter((key) => filterKey(key, options));
-		secondKeys = secondKeys.filter((key) => filterKey(key, options));
-	}
-	const { length } = firstKeys;
-	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
-	for (let index = 0; index < length; index += 1) {
-		const key = firstKeys[index];
-		if (!equalValue(first[key], second[key], options)) return false;
-	}
-	return true;
-}
-function equalProperties(first, second, properties, options) {
-	const { length } = properties;
-	for (let index = 0; index < length; index += 1) {
-		const property = properties[index];
-		if (!equalValue(first[property], second[property], options)) return false;
-	}
-	return true;
-}
-function equalSet(first, second, options) {
-	const { size } = first;
-	if (size !== second.size) return false;
-	const firstValues = [...first];
-	const secondValues = [...second];
-	for (let index = 0; index < size; index += 1) {
-		const firstValue = firstValues[index];
-		if (!secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
-	}
-	return true;
-}
-function equalTypedArray(first, second) {
-	if (first.constructor !== second.constructor) return false;
-	if (first.byteLength !== second.byteLength) return false;
-	const { length } = first;
-	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
-	return true;
-}
-function equalValue(first, second, options) {
-	if (options.relaxedNullish && first == null && second == null) return true;
-	switch (true) {
-		case Object.is(first, second): return true;
-		case first == null || second == null: return first === second;
-		case typeof first !== typeof second: return false;
-		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
-		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
-		case first instanceof Date && second instanceof Date: return Object.is(Number(first), Number(second));
-		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
-		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ["name", "message"], options);
-		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
-		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, ["source", "flags"], options);
-		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
-		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
-		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
-		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		default: return equalHandlers.handle(first, second, options);
-	}
-}
-/**
-* Create an equalizer with predefined options
-* @param options Comparison options
-* @returns Equalizer function
-*/
-function initializeEqualizer(options) {
-	const actual = getEqualOptions(options);
-	return (first, second) => equalValue(first, second, actual);
+function clone(value) {
+	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
 }
 /**
-* Register a equality comparison function for a specific class
+* Register a clone handler for a specific class
 * @param constructor Class constructor
-* @param fn Comparison function
+* @param handler Method name or clone function _(defaults to `clone`)_
 */
-function registerEqualizer(constructor, fn) {
-	equalHandlers.register(constructor, fn);
+function registerCloner(constructor, handler) {
+	cloneHandlers.register(constructor, handler);
 }
 /**
-* Unregister a equality comparison handler for a specific class
+* Unregister a clone handler for a specific class
 * @param constructor Class constructor
 */
-function unregisterEqualizer(constructor) {
-	equalHandlers.unregister(constructor);
-}
-function filterKey(key, options) {
-	if (typeof key !== "string") return true;
-	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
-	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
-	return true;
-}
-function getEqualOptions(input) {
-	const options = {
-		ignoreCase: false,
-		ignoreExpressions: {
-			enabled: false,
-			values: []
-		},
-		ignoreKeys: {
-			enabled: false,
-			values: /* @__PURE__ */ new Set()
-		},
-		relaxedNullish: false
-	};
-	if (typeof input === "boolean") {
-		options.ignoreCase = input;
-		return options;
-	}
-	if (!isPlainObject(input)) return options;
-	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
-	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
-	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
-	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
-	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
-	options.relaxedNullish = input.relaxedNullish === true;
-	return options;
-}
-const equalHandlers = getCompareHandlers(equal, { callback: Object.is });
-const ARRAY_PEEK_PERCENTAGE = 10;
-const ARRAY_THRESHOLD = 100;
-function clone(value) {
-	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
+function unregisterCloner(constructor) {
+	cloneHandlers.unregister(constructor);
 }
 function cloneArrayBuffer(value, depth, references) {
 	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
@@ -3076,161 +3091,6 @@ const cloneHandlers = getSelfHandlers(clone, {
 });
 const MAX_CLONE_DEPTH = 100;
 /**
-* Find the differences between two values
-* @param first First value
-* @param second Second value
-* @param options Comparison options
-* @returns Difference result
-*/
-function diff(first, second, options) {
-	const relaxedNullish = typeof options === "object" && options?.relaxedNullish === true;
-	const diffResult = {
-		original: {
-			from: first,
-			to: second
-		},
-		type: "partial",
-		values: {}
-	};
-	const same = relaxedNullish && first == null && second == null || Object.is(first, second);
-	const firstIsArrayOrObject = isArrayOrPlainObject(first);
-	const secondIsArrayOrObject = isArrayOrPlainObject(second);
-	if (same || !(firstIsArrayOrObject || secondIsArrayOrObject)) {
-		diffResult.type = same ? "none" : "full";
-		return diffResult;
-	}
-	if (firstIsArrayOrObject !== secondIsArrayOrObject) {
-		diffResult.type = "full";
-		return diffResult;
-	}
-	const diffs = getDiffs(first, second, relaxedNullish);
-	const { length } = diffs;
-	if (length === 0) diffResult.type = "none";
-	for (let index = 0; index < length; index += 1) {
-		const differences = diffs[index];
-		diffResult.values[differences.key] = {
-			from: differences.from,
-			to: differences.to
-		};
-	}
-	return diffResult;
-}
-function getChanges(changes, first, second, relaxedNullish, prefix) {
-	const checked = /* @__PURE__ */ new Set();
-	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
-		const value = (outerIndex === 0 ? first : second) ?? {};
-		const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-		const { length } = keys;
-		for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
-			const key = keys[innerIndex];
-			if (checked.has(key)) continue;
-			checked.add(key);
-			setChanges({
-				changes,
-				key,
-				relaxedNullish,
-				prefix,
-				values: {
-					first,
-					second
-				}
-			});
-		}
-	}
-	return changes;
-}
-function getDiffs(first, second, relaxedNullish, prefix) {
-	const changes = [];
-	if (Array.isArray(first) && Array.isArray(second)) {
-		const maximumLength = Math.max(first.length, second.length);
-		const minimumLength = Math.min(first.length, second.length);
-		for (let index = minimumLength; index < maximumLength; index += 1) {
-			const key = join([prefix, index], ".");
-			changes.push({
-				key,
-				from: index >= first.length ? void 0 : first[index],
-				to: index >= first.length ? second[index] : void 0
-			});
-		}
-	}
-	return getChanges(changes, first, second, relaxedNullish, prefix);
-}
-function setChanges(parameters) {
-	const { changes, key, prefix, relaxedNullish, values } = parameters;
-	const from = values.first?.[key];
-	const to = values.second?.[key];
-	if (equal(from, to, { relaxedNullish })) return;
-	const prefixed = join([prefix, key], ".");
-	const change = {
-		from,
-		to,
-		key: prefixed
-	};
-	const diffs = isArrayOrPlainObject(from) || isArrayOrPlainObject(to) ? getDiffs(from, to, relaxedNullish, prefixed) : [];
-	changes.push(change);
-	const diffsLength = diffs.length;
-	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
-}
-function getMergeOptions(options) {
-	const actual = {
-		replaceableObjects: void 0,
-		skipNullableInArrays: false
-	};
-	if (typeof options !== "object" || options == null) return actual;
-	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
-	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));
-}
-/**
-* 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 (isArray && options.skipNullableInArrays && next == null) 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] ?? {};
-}
-/**
 * Create a new object with only the specified keys
 * @param value Original object
 * @param keys Keys to use
@@ -3311,4 +3171,63 @@ function unsmush(value) {
 	}
 	return unsmushed;
 }
-export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, asyncResult, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupArraysBy, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, includes, indexOf, initializeEqualizer, initializeMerger, initializeTemplater, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, registerComparator, registerEqualizer, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toSet, trim, truncate, unique, unregisterComparator, unregisterEqualizer, unsmush, unwrap, upperCase, words };
+function getMergeOptions(options) {
+	const actual = {
+		replaceableObjects: void 0,
+		skipNullableInArrays: false
+	};
+	if (typeof options !== "object" || options == null) return actual;
+	actual.replaceableObjects = getReplaceableObjects(options.replaceableObjects);
+	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));
+}
+/**
+* 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 (isArray && options.skipNullableInArrays && next == null) 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] ?? {};
+}
+export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, asyncResult, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, debounce, delay, endsWith, equal, error, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupArraysBy, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, includes, indexOf, initializeEqualizer, initializeMerger, initializeTemplater, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, registerCloner, registerComparator, registerEqualizer, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toSet, trim, truncate, unique, unregisterCloner, unregisterComparator, unregisterEqualizer, unsmush, unwrap, upperCase, words };

package/dist/index.js

@@ -35,25 +35,23 @@ import frame_rate_default from "./internal/frame-rate.js";
 import { isEmpty, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumerical, isObject, isPrimitive } from "./is.js";
 import { SizedMap, SizedSet } from "./sized.js";
 import { debounce, memoize, throttle } from "./function.js";
+import { equal, initializeEqualizer, registerEqualizer, unregisterEqualizer } from "./internal/value/equal.js";
 import { logger } from "./logger.js";
 import { average, count, min, round, sum } from "./math.js";
 import { PromiseTimeoutError, delay, isFulfilled, isRejected, promises, timed } from "./promise.js";
-import { QueueError, queue } from "./queue.js";
 import { setValue } from "./internal/value/set.js";
 import { fromQuery, toQuery } from "./query.js";
+import { QueueError, queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, getRandomItem, getRandomItems } from "./random.js";
 import { asyncResult, error, isError, isOk, isResult, ok, result, unwrap } from "./result.js";
 import { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase } from "./string/case.js";
 import { endsWith, getUuid, includes, parse, startsWith, trim, truncate } from "./string/misc.js";
+import "./string/index.js";
 import { getValue } from "./internal/value/get.js";
 import { initializeTemplater, template } from "./string/template.js";
-import "./string/index.js";
-import { equal, initializeEqualizer, registerEqualizer, unregisterEqualizer } from "./internal/value/equal.js";
-import { clone } from "./value/clone.js";
-import { diff } from "./value/diff.js";
-import { initializeMerger, merge } from "./value/merge.js";
+import { clone, registerCloner, unregisterCloner } from "./value/clone.js";
 import { partial } from "./value/partial.js";
 import { smush } from "./value/smush.js";
 import { unsmush } from "./value/unsmush.js";
-import "./value/index.js";
-export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, asyncResult, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupArraysBy, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, includes, indexOf, initializeEqualizer, initializeMerger, initializeTemplater, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, registerComparator, registerEqualizer, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toSet, trim, truncate, unique, unregisterComparator, unregisterEqualizer, unsmush, unwrap, upperCase, words };
+import { initializeMerger, merge } from "./value/merge.js";
+export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, asyncResult, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, debounce, delay, endsWith, equal, error, exists, filter, find, flatten, fromQuery, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupArraysBy, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, includes, indexOf, initializeEqualizer, initializeMerger, initializeTemplater, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, registerCloner, registerComparator, registerEqualizer, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toSet, trim, truncate, unique, unregisterCloner, unregisterComparator, unregisterEqualizer, unsmush, unwrap, upperCase, words };

package/dist/string/index.js

@@ -1,5 +1,4 @@
 import { getString, join, words } from "../internal/string.js";
 import { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase } from "./case.js";
 import { endsWith, getUuid, includes, parse, startsWith, trim, truncate } from "./misc.js";
-import { initializeTemplater, template } from "./template.js";
-export { camelCase, capitalize, endsWith, getString, getUuid, includes, initializeTemplater, join, kebabCase, lowerCase, parse, pascalCase, snakeCase, startsWith, template, titleCase, trim, truncate, upperCase, words };
+export { camelCase, capitalize, endsWith, getString, getUuid, includes, join, kebabCase, lowerCase, parse, pascalCase, snakeCase, startsWith, titleCase, trim, truncate, upperCase, words };

package/dist/value/index.js

@@ -1,11 +1,6 @@
-import { compare, registerComparator, unregisterComparator } from "../internal/value/compare.js";
 import { setValue } from "../internal/value/set.js";
 import { getValue } from "../internal/value/get.js";
-import { equal, initializeEqualizer, registerEqualizer, unregisterEqualizer } from "../internal/value/equal.js";
-import { clone } from "./clone.js";
-import { diff } from "./diff.js";
-import { initializeMerger, merge } from "./merge.js";
 import { partial } from "./partial.js";
 import { smush } from "./smush.js";
 import { unsmush } from "./unsmush.js";
-export { clone, compare, diff, equal, getValue, initializeEqualizer, initializeMerger, merge, partial, registerComparator, registerEqualizer, setValue, smush, unregisterComparator, unregisterEqualizer, unsmush };
+export { getValue, partial, setValue, smush, unsmush };

package/package.json

@@ -89,9 +89,33 @@
 			"types": "./types/string/index.d.ts",
 			"default": "./dist/string/index.js"
 		},
+		"./string/template": {
+			"types": "./types/string/template.d.ts",
+			"default": "./dist/string/template.js"
+		},
 		"./value": {
 			"types": "./types/value/index.d.ts",
 			"default": "./dist/value/index.js"
+		},
+		"./value/clone": {
+			"types": "./types/value/clone.d.ts",
+			"default": "./dist/value/clone.js"
+		},
+		"./value/compare": {
+			"types": "./types/internal/value/compare.d.ts",
+			"default": "./dist/internal/value/compare.js"
+		},
+		"./value/diff": {
+			"types": "./types/value/diff.d.ts",
+			"default": "./dist/value/diff.js"
+		},
+		"./value/equal": {
+			"types": "./types/internal/value/equal.d.ts",
+			"default": "./dist/internal/value/equal.js"
+		},
+		"./value/merge": {
+			"types": "./types/value/merge.d.ts",
+			"default": "./dist/value/merge.js"
 		}
 	},
 	"files": [
@@ -120,5 +144,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.137.0"
+	"version": "0.139.0"
 }

package/src/index.ts

@@ -4,18 +4,23 @@ export * from './array/index';
 export * from './beacon';
 export * from './color/index';
 export * from './function';
+export * from './internal/value/compare';
+export * from './internal/value/equal';
 export * from './is';
 export * from './logger';
 export * from './math';
 export * from './models';
 export * from './number';
 export * from './promise';
-export * from './queue';
 export * from './query';
+export * from './queue';
 export * from './random';
 export * from './result';
 export * from './sized';
 export * from './string/index';
+export * from './string/template';
+export * from './value/clone';
 export * from './value/index';
+export * from './value/merge';
 
 export {FRAME_RATE_MS};

package/src/string/index.ts

@@ -11,4 +11,3 @@ export {
 	upperCase,
 } from './case';
 export {endsWith, getUuid, includes, parse, startsWith, trim, truncate} from './misc';
-export {initializeTemplater, template, type TemplateOptions} from './template';

package/src/string/template.ts

@@ -1,6 +1,6 @@
+import {isPlainObject} from '../internal/is';
 import {getString} from '../internal/string';
 import {getValue} from '../internal/value/get';
-import {isPlainObject} from '../is';
 import type {PlainObject} from '../models';
 
 // #region Types

package/src/value/index.ts

@@ -1,17 +1,6 @@
-export {compare, registerComparator, unregisterComparator} from '../internal/value/compare';
-export {
-	equal,
-	initializeEqualizer,
-	registerEqualizer,
-	unregisterEqualizer,
-	type EqualOptions,
-} from '../internal/value/equal';
 export {getValue} from '../internal/value/get';
 export {setValue} from '../internal/value/set';
 export type {ArrayOrPlainObject, NestedPartial, PlainObject} from '../models';
-export {clone} from './clone';
-export {diff, type DiffOptions, type DiffResult, type DiffValue} from './diff';
-export {merge, initializeMerger, type MergeOptions} from './merge';
 export {partial} from './partial';
 export {smush} from './smush';
 export {unsmush} from './unsmush';

package/types/index.d.ts

@@ -3,17 +3,22 @@ export * from './array/index';
 export * from './beacon';
 export * from './color/index';
 export * from './function';
+export * from './internal/value/compare';
+export * from './internal/value/equal';
 export * from './is';
 export * from './logger';
 export * from './math';
 export * from './models';
 export * from './number';
 export * from './promise';
-export * from './queue';
 export * from './query';
+export * from './queue';
 export * from './random';
 export * from './result';
 export * from './sized';
 export * from './string/index';
+export * from './string/template';
+export * from './value/clone';
 export * from './value/index';
+export * from './value/merge';
 export { FRAME_RATE_MS };

package/types/string/index.d.ts

@@ -2,4 +2,3 @@ export { getString, join, words } from '../internal/string';
 export type { PlainObject } from '../models';
 export { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase, } from './case';
 export { endsWith, getUuid, includes, parse, startsWith, trim, truncate } from './misc';
-export { initializeTemplater, template, type TemplateOptions } from './template';

package/types/value/index.d.ts

@@ -1,11 +1,6 @@
-export { compare, registerComparator, unregisterComparator } from '../internal/value/compare';
-export { equal, initializeEqualizer, registerEqualizer, unregisterEqualizer, type EqualOptions, } from '../internal/value/equal';
 export { getValue } from '../internal/value/get';
 export { setValue } from '../internal/value/set';
 export type { ArrayOrPlainObject, NestedPartial, PlainObject } from '../models';
-export { clone } from './clone';
-export { diff, type DiffOptions, type DiffResult, type DiffValue } from './diff';
-export { merge, initializeMerger, type MergeOptions } from './merge';
 export { partial } from './partial';
 export { smush } from './smush';
 export { unsmush } from './unsmush';