@oscarpalmer/atoms 0.168.0 → 0.169.0

package/dist/index.d.mts

@@ -2980,6 +2980,12 @@ declare function isNumber(value: unknown): value is number;
  * @returns `true` if the value is a plain object, otherwise `false`
  */
 declare function isPlainObject(value: unknown): value is PlainObject;
+/**
+ * - Is the value a primitive value?
+ * @param value Value to check
+ * @returns `true` if the value matches, otherwise `false`
+ */
+declare function isPrimitive(value: unknown): value is Primitive;
 /**
  * Is the value a typed array?
  * @param value Value to check
@@ -3030,12 +3036,6 @@ declare function isNumerical(value: unknown): value is number | `${number}`;
  * @returns `true` if the value matches, otherwise `false`
  */
 declare function isObject(value: unknown): value is object;
-/**
- * - Is the value a primitive value?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
-declare function isPrimitive(value: unknown): value is Primitive;
 //#endregion
 //#region src/logger.d.ts
 declare class Logger {

package/dist/index.mjs

@@ -215,6 +215,14 @@ function isPlainObject(value) {
 	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
 /**
+* - Is the value a primitive value?
+* @param value Value to check
+* @returns `true` if the value matches, otherwise `false`
+*/
+function isPrimitive(value) {
+	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
+}
+/**
 * Is the value a typed array?
 * @param value Value to check
 * @returns `true` if the value is a typed array, otherwise `false`
@@ -235,6 +243,7 @@ function isTypedArray(value) {
 	]);
 	return TYPED_ARRAYS.has(value?.constructor);
 }
+const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
 let TYPED_ARRAYS;
 //#endregion
 //#region src/internal/random.ts
@@ -1255,7 +1264,7 @@ var SizedMap = class extends Map {
 	* Is the Map full?
 	*/
 	get full() {
-		return this.size >= this.#maximumSize;
+		return super.size >= this.#maximumSize;
 	}
 	get maximum() {
 		return this.#maximumSize;
@@ -1274,17 +1283,23 @@ var SizedMap = class extends Map {
 	* @inheritdoc
 	*/
 	get(key) {
-		const value = super.get(key);
-		if (value !== void 0 || this.has(key)) this.set(key, value);
-		return value;
+		if (super.has(key)) {
+			const value = super.get(key);
+			this.#setValue(key, value, true);
+			return value;
+		}
 	}
 	/**
 	* @inheritdoc
 	*/
 	set(key, value) {
-		if (this.has(key)) this.delete(key);
-		else if (this.size >= this.#maximumSize) this.delete(this.keys().next().value);
-		return super.set(key, value);
+		return this.#setValue(key, value, super.has(key));
+	}
+	#setValue(key, value, has) {
+		if (has) super.delete(key);
+		else if (super.size >= this.#maximumSize) super.delete(super.keys().next().value);
+		super.set(key, value);
+		return this;
 	}
 };
 //#endregion
@@ -1685,15 +1700,8 @@ function equalArray(first, second, options) {
 		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;
-	}
+	const end = length - offset;
+	for (let index = offset; index < end; index += 1) if (!equalValue(first[index], second[index], options)) return false;
 	return true;
 }
 function equalArrayBuffer(first, second, options) {
@@ -1706,11 +1714,9 @@ 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;
+		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) return false;
 	}
 	return true;
 }
@@ -1721,11 +1727,12 @@ function equalPlainObject(first, second, options) {
 		firstKeys = firstKeys.filter((key) => filterKey(key, options));
 		secondKeys = secondKeys.filter((key) => filterKey(key, options));
 	}
+	const secondSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
 	const { length } = firstKeys;
-	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	if (length !== secondKeys.length) return false;
 	for (let index = 0; index < length; index += 1) {
 		const key = firstKeys[index];
-		if (!equalValue(first[key], second[key], options)) return false;
+		if (!(secondSet?.has(key) ?? secondKeys.includes(key)) || !equalValue(first[key], second[key], options)) return false;
 	}
 	return true;
 }
@@ -1744,7 +1751,7 @@ function equalSet(first, second, options) {
 	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;
+		if (isPrimitive(firstValue) ? !second.has(firstValue) : !secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
 	}
 	return true;
 }
@@ -1838,6 +1845,7 @@ const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
 const ERROR_PROPERTIES = ["name", "message"];
 const EXPRESSION_PROPERTIES = ["source", "flags"];
+const MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
@@ -2242,18 +2250,12 @@ function cloneDataView(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
-function cloneMapOrSet(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	const isMap = value instanceof Map;
-	const cloned = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
-	const entries = [...value.entries()];
-	const { length } = entries;
-	for (let index = 0; index < length; index += 1) {
-		const entry = entries[index];
-		if (isMap) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
-		else cloned.add(cloneValue(entry[0], depth + 1, references));
-	}
-	references.set(value, cloned);
+function cloneMap(map, depth, references) {
+	if (depth >= MAX_CLONE_DEPTH) return map;
+	const cloned = /* @__PURE__ */ new Map();
+	const entries = map.entries();
+	for (const entry of entries) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
+	references.set(map, cloned);
 	return cloned;
 }
 function cloneNode(node, depth, references) {
@@ -2281,6 +2283,15 @@ function cloneRegularExpression(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
+function cloneSet(set, depth, references) {
+	if (depth >= MAX_CLONE_DEPTH) return set;
+	const cloned = /* @__PURE__ */ new Set();
+	const values = [...set.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) cloned.add(cloneValue(values[index], depth + 1, references));
+	references.set(set, cloned);
+	return cloned;
+}
 function cloneTypedArray(value, depth, references) {
 	if (depth >= MAX_CLONE_DEPTH) return value;
 	const cloned = new value.constructor(value);
@@ -2301,9 +2312,9 @@ function cloneValue(value, depth, references) {
 		case value instanceof DataView: return cloneDataView(value, depth, references);
 		case value instanceof Date: return new Date(value.getTime());
 		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
-		case value instanceof Map:
-		case value instanceof Set: return cloneMapOrSet(value, depth, references);
+		case value instanceof Map: return cloneMap(value, depth, references);
 		case value instanceof Node: return cloneNode(value, depth, references);
+		case value instanceof Set: return cloneSet(value, depth, references);
 		case isArrayOrPlainObject(value): return clonePlainObject(value, depth, references);
 		case isTypedArray(value): return cloneTypedArray(value, depth, references);
 		default: return clone.handlers.handle(value, depth, references);
@@ -2351,7 +2362,7 @@ function diff(first, second, options) {
 		diffResult.type = DIFF_FULL;
 		return diffResult;
 	}
-	const diffs = getDiffs(first, second, relaxedNullish);
+	const diffs = getDiffs(first, second, { relaxedNullish });
 	const { length } = diffs;
 	if (length === 0) diffResult.type = DIFF_NONE;
 	for (let index = 0; index < length; index += 1) {
@@ -2363,7 +2374,7 @@ function diff(first, second, options) {
 	}
 	return diffResult;
 }
-function getChanges(changes, first, second, relaxedNullish, prefix) {
+function getChanges(changes, first, second, options, prefix) {
 	const checked = /* @__PURE__ */ new Set();
 	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
 		const value = (outerIndex === 0 ? first : second) ?? {};
@@ -2376,7 +2387,7 @@ function getChanges(changes, first, second, relaxedNullish, prefix) {
 			setChanges({
 				changes,
 				key,
-				relaxedNullish,
+				options,
 				prefix,
 				values: {
 					first,
@@ -2387,7 +2398,7 @@ function getChanges(changes, first, second, relaxedNullish, prefix) {
 	}
 	return changes;
 }
-function getDiffs(first, second, relaxedNullish, prefix) {
+function getDiffs(first, second, options, prefix) {
 	const changes = [];
 	if (Array.isArray(first) && Array.isArray(second)) {
 		const maximumLength = Math.max(first.length, second.length);
@@ -2401,20 +2412,21 @@ function getDiffs(first, second, relaxedNullish, prefix) {
 			});
 		}
 	}
-	return getChanges(changes, first, second, relaxedNullish, prefix);
+	return getChanges(changes, first, second, options, prefix);
 }
 function setChanges(parameters) {
-	const { changes, key, prefix, relaxedNullish, values } = parameters;
+	const { changes, key, prefix, options, values } = parameters;
+	const prefixed = join([prefix, key], ".");
 	const from = values.first?.[key];
 	const to = values.second?.[key];
-	if (equal(from, to, { relaxedNullish })) return;
-	const prefixed = join([prefix, key], ".");
+	const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
+	const diffs = nested ? getDiffs(from, to, options, prefixed) : [];
+	if (nested ? diffs.length === 0 : equal(from, to, options)) return;
 	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]);
@@ -3484,15 +3496,6 @@ function isNumerical(value) {
 function isObject(value) {
 	return typeof value === "object" && value !== null || typeof value === "function";
 }
-/**
-* - Is the value a primitive value?
-* @param value Value to check
-* @returns `true` if the value matches, otherwise `false`
-*/
-function isPrimitive(value) {
-	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
-}
-const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
 const EXPRESSION_WHITESPACE = /^\s*$/;
 //#endregion
 //#region src/logger.ts
@@ -4427,8 +4430,8 @@ var SizedSet = class extends Set {
 	* @inheritdoc
 	*/
 	add(value) {
-		if (this.has(value)) this.delete(value);
-		else if (this.size >= this.#maximumSize) this.delete(this.values().next().value);
+		if (super.has(value)) super.delete(value);
+		else if (this.size >= this.#maximumSize) super.delete(this.values().next().value);
 		return super.add(value);
 	}
 	/**
@@ -4438,9 +4441,9 @@ var SizedSet = class extends Set {
 	* @returns Found value if it exists, otherwise `undefined`
 	*/
 	get(value, update) {
-		if (this.has(value)) {
+		if (super.has(value)) {
 			if (update ?? false) {
-				this.delete(value);
+				super.delete(value);
 				this.add(value);
 			}
 			return value;

package/dist/internal/is.d.mts

@@ -1,4 +1,4 @@
-import { ArrayOrPlainObject, Constructor, Key, PlainObject, TypedArray } from "../models.mjs";
+import { ArrayOrPlainObject, Constructor, Key, PlainObject, Primitive, TypedArray } from "../models.mjs";
 
 //#region src/internal/is.d.ts
 /**
@@ -38,6 +38,12 @@ declare function isNumber(value: unknown): value is number;
  * @returns `true` if the value is a plain object, otherwise `false`
  */
 declare function isPlainObject(value: unknown): value is PlainObject;
+/**
+ * - Is the value a primitive value?
+ * @param value Value to check
+ * @returns `true` if the value matches, otherwise `false`
+ */
+declare function isPrimitive(value: unknown): value is Primitive;
 /**
  * Is the value a typed array?
  * @param value Value to check
@@ -45,4 +51,4 @@ declare function isPlainObject(value: unknown): value is PlainObject;
  */
 declare function isTypedArray(value: unknown): value is TypedArray;
 //#endregion
-export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray };
+export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isPrimitive, isTypedArray };

package/dist/internal/is.mjs

@@ -52,6 +52,14 @@ function isPlainObject(value) {
 	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
 /**
+* - Is the value a primitive value?
+* @param value Value to check
+* @returns `true` if the value matches, otherwise `false`
+*/
+function isPrimitive(value) {
+	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
+}
+/**
 * Is the value a typed array?
 * @param value Value to check
 * @returns `true` if the value is a typed array, otherwise `false`
@@ -72,6 +80,7 @@ function isTypedArray(value) {
 	]);
 	return TYPED_ARRAYS.has(value?.constructor);
 }
+const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
 let TYPED_ARRAYS;
 //#endregion
-export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray };
+export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isPrimitive, isTypedArray };

package/dist/internal/value/equal.mjs

@@ -1,5 +1,4 @@
-import { isPlainObject, isTypedArray } from "../is.mjs";
-import { chunk } from "../array/chunk.mjs";
+import { isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
 import { getCompareHandlers } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
 function equal(first, second, options) {
@@ -18,15 +17,8 @@ function equalArray(first, second, options) {
 		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;
-	}
+	const end = length - offset;
+	for (let index = offset; index < end; index += 1) if (!equalValue(first[index], second[index], options)) return false;
 	return true;
 }
 function equalArrayBuffer(first, second, options) {
@@ -39,11 +31,9 @@ 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;
+		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) return false;
 	}
 	return true;
 }
@@ -54,11 +44,12 @@ function equalPlainObject(first, second, options) {
 		firstKeys = firstKeys.filter((key) => filterKey(key, options));
 		secondKeys = secondKeys.filter((key) => filterKey(key, options));
 	}
+	const secondSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
 	const { length } = firstKeys;
-	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	if (length !== secondKeys.length) return false;
 	for (let index = 0; index < length; index += 1) {
 		const key = firstKeys[index];
-		if (!equalValue(first[key], second[key], options)) return false;
+		if (!(secondSet?.has(key) ?? secondKeys.includes(key)) || !equalValue(first[key], second[key], options)) return false;
 	}
 	return true;
 }
@@ -77,7 +68,7 @@ function equalSet(first, second, options) {
 	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;
+		if (isPrimitive(firstValue) ? !second.has(firstValue) : !secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
 	}
 	return true;
 }
@@ -171,5 +162,6 @@ const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
 const ERROR_PROPERTIES = ["name", "message"];
 const EXPRESSION_PROPERTIES = ["source", "flags"];
+const MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
 export { equal };

package/dist/is.d.mts

@@ -1,5 +1,4 @@
-import { Primitive } from "./models.mjs";
-import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.mjs";
+import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isPrimitive, isTypedArray } from "./internal/is.mjs";
 
 //#region src/is.d.ts
 /**
@@ -44,11 +43,5 @@ declare function isNumerical(value: unknown): value is number | `${number}`;
  * @returns `true` if the value matches, otherwise `false`
  */
 declare function isObject(value: unknown): value is object;
-/**
- * - Is the value a primitive value?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
-declare function isPrimitive(value: unknown): value is Primitive;
 //#endregion
 export { isArrayOrPlainObject, isConstructor, isEmpty, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isTypedArray };

package/dist/is.mjs

@@ -1,4 +1,4 @@
-import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.mjs";
+import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isPrimitive, isTypedArray } from "./internal/is.mjs";
 import { getArray } from "./array/get.mjs";
 import { getString } from "./internal/string.mjs";
 //#region src/is.ts
@@ -63,15 +63,6 @@ function isNumerical(value) {
 function isObject(value) {
 	return typeof value === "object" && value !== null || typeof value === "function";
 }
-/**
-* - Is the value a primitive value?
-* @param value Value to check
-* @returns `true` if the value matches, otherwise `false`
-*/
-function isPrimitive(value) {
-	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
-}
-const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
 const EXPRESSION_WHITESPACE = /^\s*$/;
 //#endregion
 export { isArrayOrPlainObject, isConstructor, isEmpty, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isTypedArray };

package/dist/sized/map.mjs

@@ -14,7 +14,7 @@ var SizedMap = class extends Map {
 	* Is the Map full?
 	*/
 	get full() {
-		return this.size >= this.#maximumSize;
+		return super.size >= this.#maximumSize;
 	}
 	get maximum() {
 		return this.#maximumSize;
@@ -33,17 +33,23 @@ var SizedMap = class extends Map {
 	* @inheritdoc
 	*/
 	get(key) {
-		const value = super.get(key);
-		if (value !== void 0 || this.has(key)) this.set(key, value);
-		return value;
+		if (super.has(key)) {
+			const value = super.get(key);
+			this.#setValue(key, value, true);
+			return value;
+		}
 	}
 	/**
 	* @inheritdoc
 	*/
 	set(key, value) {
-		if (this.has(key)) this.delete(key);
-		else if (this.size >= this.#maximumSize) this.delete(this.keys().next().value);
-		return super.set(key, value);
+		return this.#setValue(key, value, super.has(key));
+	}
+	#setValue(key, value, has) {
+		if (has) super.delete(key);
+		else if (super.size >= this.#maximumSize) super.delete(super.keys().next().value);
+		super.set(key, value);
+		return this;
 	}
 };
 //#endregion

package/dist/sized/set.mjs

@@ -32,8 +32,8 @@ var SizedSet = class extends Set {
 	* @inheritdoc
 	*/
 	add(value) {
-		if (this.has(value)) this.delete(value);
-		else if (this.size >= this.#maximumSize) this.delete(this.values().next().value);
+		if (super.has(value)) super.delete(value);
+		else if (this.size >= this.#maximumSize) super.delete(this.values().next().value);
 		return super.add(value);
 	}
 	/**
@@ -43,9 +43,9 @@ var SizedSet = class extends Set {
 	* @returns Found value if it exists, otherwise `undefined`
 	*/
 	get(value, update) {
-		if (this.has(value)) {
+		if (super.has(value)) {
 			if (update ?? false) {
-				this.delete(value);
+				super.delete(value);
 				this.add(value);
 			}
 			return value;

package/dist/value/clone.mjs

@@ -40,18 +40,12 @@ function cloneDataView(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
-function cloneMapOrSet(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
-	const isMap = value instanceof Map;
-	const cloned = isMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
-	const entries = [...value.entries()];
-	const { length } = entries;
-	for (let index = 0; index < length; index += 1) {
-		const entry = entries[index];
-		if (isMap) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
-		else cloned.add(cloneValue(entry[0], depth + 1, references));
-	}
-	references.set(value, cloned);
+function cloneMap(map, depth, references) {
+	if (depth >= MAX_CLONE_DEPTH) return map;
+	const cloned = /* @__PURE__ */ new Map();
+	const entries = map.entries();
+	for (const entry of entries) cloned.set(cloneValue(entry[0], depth + 1, references), cloneValue(entry[1], depth + 1, references));
+	references.set(map, cloned);
 	return cloned;
 }
 function cloneNode(node, depth, references) {
@@ -79,6 +73,15 @@ function cloneRegularExpression(value, depth, references) {
 	references.set(value, cloned);
 	return cloned;
 }
+function cloneSet(set, depth, references) {
+	if (depth >= MAX_CLONE_DEPTH) return set;
+	const cloned = /* @__PURE__ */ new Set();
+	const values = [...set.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) cloned.add(cloneValue(values[index], depth + 1, references));
+	references.set(set, cloned);
+	return cloned;
+}
 function cloneTypedArray(value, depth, references) {
 	if (depth >= MAX_CLONE_DEPTH) return value;
 	const cloned = new value.constructor(value);
@@ -99,9 +102,9 @@ function cloneValue(value, depth, references) {
 		case value instanceof DataView: return cloneDataView(value, depth, references);
 		case value instanceof Date: return new Date(value.getTime());
 		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
-		case value instanceof Map:
-		case value instanceof Set: return cloneMapOrSet(value, depth, references);
+		case value instanceof Map: return cloneMap(value, depth, references);
 		case value instanceof Node: return cloneNode(value, depth, references);
+		case value instanceof Set: return cloneSet(value, depth, references);
 		case isArrayOrPlainObject(value): return clonePlainObject(value, depth, references);
 		case isTypedArray(value): return cloneTypedArray(value, depth, references);
 		default: return clone.handlers.handle(value, depth, references);

package/dist/value/diff.mjs

@@ -30,7 +30,7 @@ function diff(first, second, options) {
 		diffResult.type = DIFF_FULL;
 		return diffResult;
 	}
-	const diffs = getDiffs(first, second, relaxedNullish);
+	const diffs = getDiffs(first, second, { relaxedNullish });
 	const { length } = diffs;
 	if (length === 0) diffResult.type = DIFF_NONE;
 	for (let index = 0; index < length; index += 1) {
@@ -42,7 +42,7 @@ function diff(first, second, options) {
 	}
 	return diffResult;
 }
-function getChanges(changes, first, second, relaxedNullish, prefix) {
+function getChanges(changes, first, second, options, prefix) {
 	const checked = /* @__PURE__ */ new Set();
 	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
 		const value = (outerIndex === 0 ? first : second) ?? {};
@@ -55,7 +55,7 @@ function getChanges(changes, first, second, relaxedNullish, prefix) {
 			setChanges({
 				changes,
 				key,
-				relaxedNullish,
+				options,
 				prefix,
 				values: {
 					first,
@@ -66,7 +66,7 @@ function getChanges(changes, first, second, relaxedNullish, prefix) {
 	}
 	return changes;
 }
-function getDiffs(first, second, relaxedNullish, prefix) {
+function getDiffs(first, second, options, prefix) {
 	const changes = [];
 	if (Array.isArray(first) && Array.isArray(second)) {
 		const maximumLength = Math.max(first.length, second.length);
@@ -80,20 +80,21 @@ function getDiffs(first, second, relaxedNullish, prefix) {
 			});
 		}
 	}
-	return getChanges(changes, first, second, relaxedNullish, prefix);
+	return getChanges(changes, first, second, options, prefix);
 }
 function setChanges(parameters) {
-	const { changes, key, prefix, relaxedNullish, values } = parameters;
+	const { changes, key, prefix, options, values } = parameters;
+	const prefixed = join([prefix, key], ".");
 	const from = values.first?.[key];
 	const to = values.second?.[key];
-	if (equal(from, to, { relaxedNullish })) return;
-	const prefixed = join([prefix, key], ".");
+	const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
+	const diffs = nested ? getDiffs(from, to, options, prefixed) : [];
+	if (nested ? diffs.length === 0 : equal(from, to, options)) return;
 	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]);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.168.0",
+	"version": "0.169.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",
@@ -235,4 +235,4 @@
 		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
 	},
 	"packageManager": "npm@11.11.1"
-}
+}

package/src/internal/is.ts

@@ -1,4 +1,11 @@
-import type {ArrayOrPlainObject, Constructor, Key, PlainObject, TypedArray} from '../models';
+import type {
+	ArrayOrPlainObject,
+	Constructor,
+	Key,
+	PlainObject,
+	Primitive,
+	TypedArray,
+} from '../models';
 
 // #region Functions
 
@@ -74,6 +81,15 @@ export function isPlainObject(value: unknown): value is PlainObject {
 	);
 }
 
+/**
+ * - Is the value a primitive value?
+ * @param value Value to check
+ * @returns `true` if the value matches, otherwise `false`
+ */
+export function isPrimitive(value: unknown): value is Primitive {
+	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
+}
+
 /**
  * Is the value a typed array?
  * @param value Value to check
@@ -101,6 +117,8 @@ export function isTypedArray(value: unknown): value is TypedArray {
 
 // #region Variables
 
+const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
+
 let TYPED_ARRAYS: Set<unknown>;
 
 // #endregion

package/src/internal/value/equal.ts

@@ -1,5 +1,5 @@
+import {isPrimitive} from '../is';
 import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../../models';
-import {chunk} from '../array/chunk';
 import {isPlainObject, isTypedArray} from '../is';
 import {getCompareHandlers} from './handlers';
 
@@ -122,21 +122,11 @@ function equalArray(first: unknown[], second: unknown[], options: Options): bool
 		}
 	}
 
-	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const end = length - offset;
 
-	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;
-			}
+	for (let index = offset; index < end; index += 1) {
+		if (!equalValue(first[index], second[index], options)) {
+			return false;
 		}
 	}
 
@@ -167,16 +157,11 @@ function equalMap(
 	}
 
 	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)) {
+		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) {
 			return false;
 		}
 	}
@@ -197,16 +182,22 @@ function equalPlainObject(
 		secondKeys = secondKeys.filter(key => filterKey(key, options));
 	}
 
+	const useSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET;
+	const secondSet = useSet ? new Set(secondKeys) : undefined;
+
 	const {length} = firstKeys;
 
-	if (length !== secondKeys.length || firstKeys.some(key => !secondKeys.includes(key))) {
+	if (length !== secondKeys.length) {
 		return false;
 	}
 
 	for (let index = 0; index < length; index += 1) {
 		const key = firstKeys[index];
 
-		if (!equalValue(first[key as never], second[key as never], options)) {
+		if (
+			!(secondSet?.has(key) ?? secondKeys.includes(key)) ||
+			!equalValue(first[key as never], second[key as never], options)
+		) {
 			return false;
 		}
 	}
@@ -246,7 +237,11 @@ function equalSet(first: Set<unknown>, second: Set<unknown>, options: Options):
 	for (let index = 0; index < size; index += 1) {
 		const firstValue = firstValues[index];
 
-		if (!secondValues.some(secondValue => equalValue(firstValue, secondValue, options))) {
+		if (
+			isPrimitive(firstValue)
+				? !second.has(firstValue)
+				: !secondValues.some(secondValue => equalValue(firstValue, secondValue, options))
+		) {
 			return false;
 		}
 	}
@@ -439,4 +434,6 @@ const ERROR_PROPERTIES: string[] = ['name', 'message'];
 
 const EXPRESSION_PROPERTIES: string[] = ['source', 'flags'];
 
+const MINIMUM_LENGTH_FOR_SET = 16;
+
 // #endregion

package/src/is.ts

@@ -88,21 +88,10 @@ export function isObject(value: unknown): value is object {
 	return (typeof value === 'object' && value !== null) || typeof value === 'function';
 }
 
-/**
- * - Is the value a primitive value?
- * @param value Value to check
- * @returns `true` if the value matches, otherwise `false`
- */
-export function isPrimitive(value: unknown): value is Primitive {
-	return value == null || EXPRESSION_PRIMITIVE.test(typeof value);
-}
-
 // #endregion
 
 // #region Variables
 
-const EXPRESSION_PRIMITIVE = /^(bigint|boolean|number|string|symbol)$/;
-
 const EXPRESSION_WHITESPACE = /^\s*$/;
 
 // #endregion
@@ -116,6 +105,7 @@ export {
 	isKey,
 	isNumber,
 	isPlainObject,
+	isPrimitive,
 	isTypedArray,
 } from './internal/is';
 

package/src/sized/map.ts

@@ -17,7 +17,7 @@ export class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<Size
 	 * Is the Map full?
 	 */
 	get full(): boolean {
-		return this.size >= this.#maximumSize;
+		return super.size >= this.#maximumSize;
 	}
 
 	get maximum(): number {
@@ -75,26 +75,32 @@ export class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<Size
 	 * @inheritdoc
 	 */
 	override get(key: SizedKey): SizedValue | undefined {
-		const value = super.get(key);
+		if (super.has(key)) {
+			const value = super.get(key) as SizedValue;
 
-		if (value !== undefined || this.has(key)) {
-			this.set(key, value as SizedValue);
-		}
+			this.#setValue(key, value, true);
 
-		return value;
+			return value;
+		}
 	}
 
 	/**
 	 * @inheritdoc
 	 */
 	override set(key: SizedKey, value: SizedValue): this {
-		if (this.has(key)) {
-			this.delete(key);
-		} else if (this.size >= this.#maximumSize) {
-			this.delete(this.keys().next().value as SizedKey);
+		return this.#setValue(key, value, super.has(key));
+	}
+
+	#setValue(key: SizedKey, value: SizedValue, has: boolean): this {
+		if (has) {
+			super.delete(key);
+		} else if (super.size >= this.#maximumSize) {
+			super.delete(super.keys().next().value as SizedKey);
 		}
 
-		return super.set(key, value);
+		super.set(key, value);
+
+		return this;
 	}
 }
 

package/src/sized/set.ts

@@ -71,10 +71,10 @@ export class SizedSet<Value = unknown> extends Set<Value> {
 	 * @inheritdoc
 	 */
 	override add(value: Value): this {
-		if (this.has(value)) {
-			this.delete(value);
+		if (super.has(value)) {
+			super.delete(value);
 		} else if (this.size >= this.#maximumSize) {
-			this.delete(this.values().next().value as Value);
+			super.delete(this.values().next().value as Value);
 		}
 
 		return super.add(value);
@@ -87,9 +87,10 @@ export class SizedSet<Value = unknown> extends Set<Value> {
 	 * @returns Found value if it exists, otherwise `undefined`
 	 */
 	get(value: Value, update?: boolean): Value | undefined {
-		if (this.has(value)) {
+		if (super.has(value)) {
 			if (update ?? false) {
-				this.delete(value);
+				super.delete(value);
+
 				this.add(value);
 			}
 

package/src/value/clone.ts

@@ -86,36 +86,28 @@ function cloneDataView(
 	return cloned;
 }
 
-function cloneMapOrSet<Value extends Map<unknown, unknown> | Set<unknown>>(
-	value: Value,
+function cloneMap(
+	map: Map<unknown, unknown>,
 	depth: number,
 	references: WeakMap<WeakKey, unknown>,
-): Value {
+): Map<unknown, unknown> {
 	if (depth >= MAX_CLONE_DEPTH) {
-		return value;
+		return map;
 	}
 
-	const isMap = value instanceof Map;
-	const cloned = isMap ? new Map<unknown, unknown>() : new Set<unknown>();
-	const entries = [...value.entries()];
-	const {length} = entries;
+	const cloned = new Map<unknown, unknown>();
+	const entries = map.entries();
 
-	for (let index = 0; index < length; index += 1) {
-		const entry = entries[index];
-
-		if (isMap) {
-			(cloned as Map<unknown, unknown>).set(
-				cloneValue(entry[0], depth + 1, references),
-				cloneValue(entry[1], depth + 1, references),
-			);
-		} else {
-			(cloned as Set<unknown>).add(cloneValue(entry[0], depth + 1, references));
-		}
+	for (const entry of entries) {
+		cloned.set(
+			cloneValue(entry[0], depth + 1, references),
+			cloneValue(entry[1], depth + 1, references),
+		);
 	}
 
-	references.set(value, cloned);
+	references.set(map, cloned);
 
-	return cloned as Value;
+	return cloned;
 }
 
 function cloneNode(node: Node, depth: number, references: WeakMap<WeakKey, unknown>): Node {
@@ -172,6 +164,28 @@ function cloneRegularExpression(
 	return cloned;
 }
 
+function cloneSet(
+	set: Set<unknown>,
+	depth: number,
+	references: WeakMap<WeakKey, unknown>,
+): Set<unknown> {
+	if (depth >= MAX_CLONE_DEPTH) {
+		return set;
+	}
+
+	const cloned = new Set<unknown>();
+	const values = [...set.values()];
+	const {length} = values;
+
+	for (let index = 0; index < length; index += 1) {
+		cloned.add(cloneValue(values[index], depth + 1, references));
+	}
+
+	references.set(set, cloned);
+
+	return cloned;
+}
+
 function cloneTypedArray(
 	value: TypedArray,
 	depth: number,
@@ -227,12 +241,14 @@ function cloneValue(value: unknown, depth: number, references: WeakMap<WeakKey,
 			return cloneRegularExpression(value, depth, references);
 
 		case value instanceof Map:
-		case value instanceof Set:
-			return cloneMapOrSet(value, depth, references);
+			return cloneMap(value, depth, references);
 
 		case value instanceof Node:
 			return cloneNode(value, depth, references);
 
+		case value instanceof Set:
+			return cloneSet(value, depth, references);
+
 		case isArrayOrPlainObject(value):
 			return clonePlainObject(value, depth, references);
 

package/src/value/diff.ts

@@ -57,8 +57,8 @@ type KeyedDiffValue = {
 type Parameters = {
 	changes: KeyedDiffValue[];
 	key: PropertyKey;
+	options: Required<DiffOptions>;
 	values: {first: unknown; second: unknown};
-	relaxedNullish: boolean;
 	prefix?: string;
 };
 
@@ -106,7 +106,7 @@ export function diff<First, Second = First>(
 		return diffResult;
 	}
 
-	const diffs = getDiffs(first, second, relaxedNullish);
+	const diffs = getDiffs(first, second, {relaxedNullish});
 
 	const {length} = diffs;
 
@@ -127,7 +127,7 @@ function getChanges(
 	changes: KeyedDiffValue[],
 	first: unknown,
 	second: unknown,
-	relaxedNullish: boolean,
+	options: Required<DiffOptions>,
 	prefix?: string,
 ): KeyedDiffValue[] {
 	const checked = new Set<PropertyKey>();
@@ -151,7 +151,7 @@ function getChanges(
 			setChanges({
 				changes,
 				key,
-				relaxedNullish,
+				options,
 				prefix,
 				values: {first, second},
 			});
@@ -164,7 +164,7 @@ function getChanges(
 function getDiffs(
 	first: unknown,
 	second: unknown,
-	relaxedNullish: boolean,
+	options: Required<DiffOptions>,
 	prefix?: string,
 ): KeyedDiffValue[] {
 	const changes: KeyedDiffValue[] = [];
@@ -184,31 +184,30 @@ function getDiffs(
 		}
 	}
 
-	return getChanges(changes, first, second, relaxedNullish, prefix);
+	return getChanges(changes, first, second, options, prefix);
 }
 
 function setChanges(parameters: Parameters): void {
-	const {changes, key, prefix, relaxedNullish, values} = parameters;
+	const {changes, key, prefix, options, values} = parameters;
 
-	const from = values.first?.[key as never];
-	const to = values.second?.[key as never];
+	const prefixed = join([prefix, key], '.');
+
+	const from: unknown = values.first?.[key as never];
+	const to: unknown = values.second?.[key as never];
 
-	if (equal(from, to, {relaxedNullish})) {
+	const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
+	const diffs = nested ? getDiffs(from, to, options, prefixed) : [];
+
+	if (nested ? diffs.length === 0 : equal(from, to, options)) {
 		return;
 	}
 
-	const prefixed = join([prefix, key], '.');
-
 	const change = {
 		from,
 		to,
 		key: prefixed,
 	};
 
-	const nested = isArrayOrPlainObject(from) || isArrayOrPlainObject(to);
-
-	const diffs = nested ? getDiffs(from, to, relaxedNullish, prefixed) : [];
-
 	changes.push(change);
 
 	const diffsLength = diffs.length;