es-toolkit 1.52.0-dev.2095 → 1.52.0-dev.2096

package/dist/util/hash/sha256.mjs

@@ -0,0 +1,158 @@
+//#region src/util/hash/sha256.ts
+const K = new Int32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const BASE64_URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+/**
+* Computes the SHA-256 digest of a string and encodes it in Base64URL
+* format without padding.
+*
+* The output is byte-identical to
+* `crypto.hash('sha256', data, 'base64url')` in Node.js.
+*
+* @param data - The string to hash. Encoded as UTF-8 before hashing.
+* @returns The 43-character Base64URL-encoded digest.
+*/
+function sha256(data) {
+	const bytes = new TextEncoder().encode(data);
+	const byteLength = bytes.length;
+	const paddedLength = ((byteLength + 8 >> 6) + 1) * 64;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[byteLength] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(paddedLength - 8, Math.floor(byteLength / 536870912));
+	view.setUint32(paddedLength - 4, byteLength << 3 >>> 0);
+	let h0 = 1779033703;
+	let h1 = -1150833019;
+	let h2 = 1013904242;
+	let h3 = -1521486534;
+	let h4 = 1359893119;
+	let h5 = -1694144372;
+	let h6 = 528734635;
+	let h7 = 1541459225;
+	const w = new Int32Array(64);
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4) | 0;
+		for (let i = 16; i < 64; i++) {
+			const x = w[i - 15];
+			const y = w[i - 2];
+			const sigma0 = (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3 | 0;
+			const sigma1 = (y >>> 17 | y << 15) ^ (y >>> 19 | y << 13) ^ y >>> 10 | 0;
+			w[i] = w[i - 16] + sigma0 + w[i - 7] + sigma1 | 0;
+		}
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		let f = h5;
+		let g = h6;
+		let h = h7;
+		for (let i = 0; i < 64; i++) {
+			const bigSigma1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+			const ch = e & f ^ ~e & g;
+			const t1 = h + bigSigma1 + ch + K[i] + w[i] | 0;
+			const t2 = ((a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		h0 = h0 + a | 0;
+		h1 = h1 + b | 0;
+		h2 = h2 + c | 0;
+		h3 = h3 + d | 0;
+		h4 = h4 + e | 0;
+		h5 = h5 + f | 0;
+		h6 = h6 + g | 0;
+		h7 = h7 + h | 0;
+	}
+	const digest = new Uint8Array(32);
+	const digestView = new DataView(digest.buffer);
+	digestView.setInt32(0, h0);
+	digestView.setInt32(4, h1);
+	digestView.setInt32(8, h2);
+	digestView.setInt32(12, h3);
+	digestView.setInt32(16, h4);
+	digestView.setInt32(20, h5);
+	digestView.setInt32(24, h6);
+	digestView.setInt32(28, h7);
+	let result = "";
+	for (let i = 0; i < 30; i += 3) {
+		const n = digest[i] << 16 | digest[i + 1] << 8 | digest[i + 2];
+		result += BASE64_URL_ALPHABET[n >>> 18 & 63] + BASE64_URL_ALPHABET[n >>> 12 & 63] + BASE64_URL_ALPHABET[n >>> 6 & 63] + BASE64_URL_ALPHABET[n & 63];
+	}
+	const n = digest[30] << 8 | digest[31];
+	result += BASE64_URL_ALPHABET[n >>> 10 & 63] + BASE64_URL_ALPHABET[n >>> 4 & 63] + BASE64_URL_ALPHABET[n << 2 & 63];
+	return result;
+}
+//#endregion
+export { sha256 };

package/dist/util/index.d.mts

@@ -3,4 +3,5 @@ import { attemptAsync } from "./attemptAsync.mjs";
 import { defer } from "./defer.mjs";
 import { deferAsync } from "./deferAsync.mjs";
 import { invariant } from "./invariant.mjs";
-export { invariant as assert, attempt, attemptAsync, defer, deferAsync, invariant };
+import { serialize } from "./serialize/serialize.mjs";
+export { invariant as assert, attempt, attemptAsync, defer, deferAsync, invariant, serialize };

package/dist/util/index.d.ts

@@ -3,4 +3,5 @@ import { attemptAsync } from "./attemptAsync.js";
 import { defer } from "./defer.js";
 import { deferAsync } from "./deferAsync.js";
 import { invariant } from "./invariant.js";
-export { invariant as assert, attempt, attemptAsync, defer, deferAsync, invariant };
+import { serialize } from "./serialize/serialize.js";
+export { invariant as assert, attempt, attemptAsync, defer, deferAsync, invariant, serialize };

package/dist/util/index.js

@@ -4,9 +4,11 @@ const require_attemptAsync = require("./attemptAsync.js");
 const require_defer = require("./defer.js");
 const require_deferAsync = require("./deferAsync.js");
 const require_invariant = require("./invariant.js");
+const require_serialize = require("./serialize/serialize.js");
 exports.assert = require_invariant.invariant;
 exports.attempt = require_attempt.attempt;
 exports.attemptAsync = require_attemptAsync.attemptAsync;
 exports.defer = require_defer.defer;
 exports.deferAsync = require_deferAsync.deferAsync;
 exports.invariant = require_invariant.invariant;
+exports.serialize = require_serialize.serialize;

package/dist/util/index.mjs

@@ -3,4 +3,5 @@ import { attemptAsync } from "./attemptAsync.mjs";
 import { defer } from "./defer.mjs";
 import { deferAsync } from "./deferAsync.mjs";
 import { invariant } from "./invariant.mjs";
-export { invariant as assert, attempt, attemptAsync, defer, deferAsync, invariant };
+import { serialize } from "./serialize/serialize.mjs";
+export { invariant as assert, attempt, attemptAsync, defer, deferAsync, invariant, serialize };

package/dist/util/serialize/compareValues.js

@@ -0,0 +1,23 @@
+const require_serialize = require("./serialize.js");
+//#region src/util/serialize/compareValues.ts
+/**
+* Compares two values for sorting `Set` values and `Map` keys.
+*
+* Numbers are compared numerically and strings by code unit. Any other
+* combination is compared by the code unit order of the serialized values.
+*
+* @param a - The first value to compare.
+* @param b - The second value to compare.
+* @param refs - The circular reference context shared with the surrounding serialization.
+* @returns A negative number if `a` sorts before `b`, a positive number if
+*   `a` sorts after `b`, and `0` if they are equal.
+*/
+function compareValues(a, b, refs) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	const serializedA = typeof a === "string" && typeof b === "string" ? a : require_serialize.serializeValue(a, refs);
+	const serializedB = typeof a === "string" && typeof b === "string" ? b : require_serialize.serializeValue(b, refs);
+	if (serializedA === serializedB) return 0;
+	return serializedA < serializedB ? -1 : 1;
+}
+//#endregion
+exports.compareValues = compareValues;

package/dist/util/serialize/compareValues.mjs

@@ -0,0 +1,23 @@
+import { serializeValue } from "./serialize.mjs";
+//#region src/util/serialize/compareValues.ts
+/**
+* Compares two values for sorting `Set` values and `Map` keys.
+*
+* Numbers are compared numerically and strings by code unit. Any other
+* combination is compared by the code unit order of the serialized values.
+*
+* @param a - The first value to compare.
+* @param b - The second value to compare.
+* @param refs - The circular reference context shared with the surrounding serialization.
+* @returns A negative number if `a` sorts before `b`, a positive number if
+*   `a` sorts after `b`, and `0` if they are equal.
+*/
+function compareValues(a, b, refs) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	const serializedA = typeof a === "string" && typeof b === "string" ? a : serializeValue(a, refs);
+	const serializedB = typeof a === "string" && typeof b === "string" ? b : serializeValue(b, refs);
+	if (serializedA === serializedB) return 0;
+	return serializedA < serializedB ? -1 : 1;
+}
+//#endregion
+export { compareValues };

package/dist/util/serialize/serialize.d.mts

@@ -0,0 +1,44 @@
+//#region src/util/serialize/serialize.d.ts
+/**
+ * Serializes any value into a stable string.
+ *
+ * Two values with the same structure always serialize to the same string,
+ * regardless of key insertion order, so the output is suitable for hashing,
+ * cache keys, and change detection. It is not designed for security purposes;
+ * intentional collisions can be crafted from user input.
+ *
+ * Plain object keys, `Map` keys, and `Set` values are sorted, so the output
+ * does not depend on insertion order. String keys are always quoted, so a
+ * string key never collides with a key of another type. Circular references
+ * are serialized as `#ref{n}` back-references, where `n` is the order in
+ * which the object was first visited.
+ *
+ * Objects that cannot be serialized meaningfully, such as `Promise`, `WeakMap`,
+ * or `Blob`, throw a `TypeError`.
+ *
+ * @param value - The value to serialize.
+ * @returns The serialized string.
+ * @throws {TypeError} If the value contains an object that cannot be serialized.
+ *
+ * @example
+ * serialize({ b: 2, a: 1 }); // "{'a':1,'b':2}"
+ * serialize([1, 2n, 'a', { k: 1 }]); // "[1,2n,'a',{'k':1}]"
+ * serialize(new Set([3, 1, 2])); // "Set[1,2,3]"
+ * serialize(new Date(0)); // "Date('1970-01-01T00:00:00.000Z')"
+ *
+ * const obj = {};
+ * obj.self = obj;
+ * serialize(obj); // "{'self':#ref0}"
+ */
+declare function serialize(value: unknown): string;
+/**
+ * Serializes a value with a shared circular reference context.
+ *
+ * @param value - The value to serialize.
+ * @param refs - Objects that are being serialized or have been serialized,
+ *   mapped to their back-reference placeholder or completed serialization.
+ * @returns The serialized string.
+ */
+declare function serializeValue(value: unknown, refs: Map<object, string>): string;
+//#endregion
+export { serialize };

package/dist/util/serialize/serialize.d.ts

@@ -0,0 +1,44 @@
+//#region src/util/serialize/serialize.d.ts
+/**
+ * Serializes any value into a stable string.
+ *
+ * Two values with the same structure always serialize to the same string,
+ * regardless of key insertion order, so the output is suitable for hashing,
+ * cache keys, and change detection. It is not designed for security purposes;
+ * intentional collisions can be crafted from user input.
+ *
+ * Plain object keys, `Map` keys, and `Set` values are sorted, so the output
+ * does not depend on insertion order. String keys are always quoted, so a
+ * string key never collides with a key of another type. Circular references
+ * are serialized as `#ref{n}` back-references, where `n` is the order in
+ * which the object was first visited.
+ *
+ * Objects that cannot be serialized meaningfully, such as `Promise`, `WeakMap`,
+ * or `Blob`, throw a `TypeError`.
+ *
+ * @param value - The value to serialize.
+ * @returns The serialized string.
+ * @throws {TypeError} If the value contains an object that cannot be serialized.
+ *
+ * @example
+ * serialize({ b: 2, a: 1 }); // "{'a':1,'b':2}"
+ * serialize([1, 2n, 'a', { k: 1 }]); // "[1,2n,'a',{'k':1}]"
+ * serialize(new Set([3, 1, 2])); // "Set[1,2,3]"
+ * serialize(new Date(0)); // "Date('1970-01-01T00:00:00.000Z')"
+ *
+ * const obj = {};
+ * obj.self = obj;
+ * serialize(obj); // "{'self':#ref0}"
+ */
+declare function serialize(value: unknown): string;
+/**
+ * Serializes a value with a shared circular reference context.
+ *
+ * @param value - The value to serialize.
+ * @param refs - Objects that are being serialized or have been serialized,
+ *   mapped to their back-reference placeholder or completed serialization.
+ * @returns The serialized string.
+ */
+declare function serializeValue(value: unknown, refs: Map<object, string>): string;
+//#endregion
+export { serialize };

package/dist/util/serialize/serialize.js

@@ -0,0 +1,64 @@
+const require_serializeBigInt = require("./serializeBigInt.js");
+const require_serializeFunction = require("./serializeFunction.js");
+const require_serializeNumber = require("./serializeNumber.js");
+const require_serializeString = require("./serializeString.js");
+const require_serializeObject = require("./serializeObject.js");
+const require_serializeSymbol = require("./serializeSymbol.js");
+//#region src/util/serialize/serialize.ts
+/**
+* Serializes any value into a stable string.
+*
+* Two values with the same structure always serialize to the same string,
+* regardless of key insertion order, so the output is suitable for hashing,
+* cache keys, and change detection. It is not designed for security purposes;
+* intentional collisions can be crafted from user input.
+*
+* Plain object keys, `Map` keys, and `Set` values are sorted, so the output
+* does not depend on insertion order. String keys are always quoted, so a
+* string key never collides with a key of another type. Circular references
+* are serialized as `#ref{n}` back-references, where `n` is the order in
+* which the object was first visited.
+*
+* Objects that cannot be serialized meaningfully, such as `Promise`, `WeakMap`,
+* or `Blob`, throw a `TypeError`.
+*
+* @param value - The value to serialize.
+* @returns The serialized string.
+* @throws {TypeError} If the value contains an object that cannot be serialized.
+*
+* @example
+* serialize({ b: 2, a: 1 }); // "{'a':1,'b':2}"
+* serialize([1, 2n, 'a', { k: 1 }]); // "[1,2n,'a',{'k':1}]"
+* serialize(new Set([3, 1, 2])); // "Set[1,2,3]"
+* serialize(new Date(0)); // "Date('1970-01-01T00:00:00.000Z')"
+*
+* const obj = {};
+* obj.self = obj;
+* serialize(obj); // "{'self':#ref0}"
+*/
+function serialize(value) {
+	return serializeValue(value, /* @__PURE__ */ new Map());
+}
+/**
+* Serializes a value with a shared circular reference context.
+*
+* @param value - The value to serialize.
+* @param refs - Objects that are being serialized or have been serialized,
+*   mapped to their back-reference placeholder or completed serialization.
+* @returns The serialized string.
+*/
+function serializeValue(value, refs) {
+	switch (typeof value) {
+		case "string": return require_serializeString.serializeString(value);
+		case "number": return require_serializeNumber.serializeNumber(value);
+		case "bigint": return require_serializeBigInt.serializeBigInt(value);
+		case "symbol": return require_serializeSymbol.serializeSymbol(value);
+		case "function": return require_serializeFunction.serializeFunction(value);
+		case "object": return require_serializeObject.serializeObject(value, refs);
+		case "boolean": return String(value);
+		case "undefined": return "undefined";
+	}
+}
+//#endregion
+exports.serialize = serialize;
+exports.serializeValue = serializeValue;

package/dist/util/serialize/serialize.mjs

@@ -0,0 +1,63 @@
+import { serializeBigInt } from "./serializeBigInt.mjs";
+import { serializeFunction } from "./serializeFunction.mjs";
+import { serializeNumber } from "./serializeNumber.mjs";
+import { serializeString } from "./serializeString.mjs";
+import { serializeObject } from "./serializeObject.mjs";
+import { serializeSymbol } from "./serializeSymbol.mjs";
+//#region src/util/serialize/serialize.ts
+/**
+* Serializes any value into a stable string.
+*
+* Two values with the same structure always serialize to the same string,
+* regardless of key insertion order, so the output is suitable for hashing,
+* cache keys, and change detection. It is not designed for security purposes;
+* intentional collisions can be crafted from user input.
+*
+* Plain object keys, `Map` keys, and `Set` values are sorted, so the output
+* does not depend on insertion order. String keys are always quoted, so a
+* string key never collides with a key of another type. Circular references
+* are serialized as `#ref{n}` back-references, where `n` is the order in
+* which the object was first visited.
+*
+* Objects that cannot be serialized meaningfully, such as `Promise`, `WeakMap`,
+* or `Blob`, throw a `TypeError`.
+*
+* @param value - The value to serialize.
+* @returns The serialized string.
+* @throws {TypeError} If the value contains an object that cannot be serialized.
+*
+* @example
+* serialize({ b: 2, a: 1 }); // "{'a':1,'b':2}"
+* serialize([1, 2n, 'a', { k: 1 }]); // "[1,2n,'a',{'k':1}]"
+* serialize(new Set([3, 1, 2])); // "Set[1,2,3]"
+* serialize(new Date(0)); // "Date('1970-01-01T00:00:00.000Z')"
+*
+* const obj = {};
+* obj.self = obj;
+* serialize(obj); // "{'self':#ref0}"
+*/
+function serialize(value) {
+	return serializeValue(value, /* @__PURE__ */ new Map());
+}
+/**
+* Serializes a value with a shared circular reference context.
+*
+* @param value - The value to serialize.
+* @param refs - Objects that are being serialized or have been serialized,
+*   mapped to their back-reference placeholder or completed serialization.
+* @returns The serialized string.
+*/
+function serializeValue(value, refs) {
+	switch (typeof value) {
+		case "string": return serializeString(value);
+		case "number": return serializeNumber(value);
+		case "bigint": return serializeBigInt(value);
+		case "symbol": return serializeSymbol(value);
+		case "function": return serializeFunction(value);
+		case "object": return serializeObject(value, refs);
+		case "boolean": return String(value);
+		case "undefined": return "undefined";
+	}
+}
+//#endregion
+export { serialize, serializeValue };

package/dist/util/serialize/serializeBigInt.js

@@ -0,0 +1,15 @@
+//#region src/util/serialize/serializeBigInt.ts
+/**
+* Serializes a bigint into a string with an `n` suffix, like a bigint literal.
+*
+* @param value - The bigint to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeBigInt(123n); // "123n"
+*/
+function serializeBigInt(value) {
+	return `${value}n`;
+}
+//#endregion
+exports.serializeBigInt = serializeBigInt;

package/dist/util/serialize/serializeBigInt.mjs

@@ -0,0 +1,15 @@
+//#region src/util/serialize/serializeBigInt.ts
+/**
+* Serializes a bigint into a string with an `n` suffix, like a bigint literal.
+*
+* @param value - The bigint to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeBigInt(123n); // "123n"
+*/
+function serializeBigInt(value) {
+	return `${value}n`;
+}
+//#endregion
+export { serializeBigInt };

package/dist/util/serialize/serializeFunction.js

@@ -0,0 +1,26 @@
+//#region src/util/serialize/serializeFunction.ts
+/**
+* Serializes a function into a string of the form `name:source`.
+*
+* Native functions have no meaningful source, so they are serialized as
+* `name:[native]`. For other functions, newlines and their surrounding
+* whitespace are collapsed so that formatting differences do not change
+* the output.
+*
+* @param value - The function to serialize.
+* @returns The serialized string.
+*
+* @example
+* function sum(a, b) {
+*   return a + b;
+* }
+* serializeFunction(sum); // "sum:function sum(a, b) {return a + b;}"
+* serializeFunction(Math.max); // "max:[native]"
+*/
+function serializeFunction(value) {
+	const source = Function.prototype.toString.call(value);
+	if (source.endsWith("[native code] }")) return `${value.name}:[native]`;
+	return `${value.name}:${source.replace(/\s*\n\s*/g, "")}`;
+}
+//#endregion
+exports.serializeFunction = serializeFunction;

package/dist/util/serialize/serializeFunction.mjs

@@ -0,0 +1,26 @@
+//#region src/util/serialize/serializeFunction.ts
+/**
+* Serializes a function into a string of the form `name:source`.
+*
+* Native functions have no meaningful source, so they are serialized as
+* `name:[native]`. For other functions, newlines and their surrounding
+* whitespace are collapsed so that formatting differences do not change
+* the output.
+*
+* @param value - The function to serialize.
+* @returns The serialized string.
+*
+* @example
+* function sum(a, b) {
+*   return a + b;
+* }
+* serializeFunction(sum); // "sum:function sum(a, b) {return a + b;}"
+* serializeFunction(Math.max); // "max:[native]"
+*/
+function serializeFunction(value) {
+	const source = Function.prototype.toString.call(value);
+	if (source.endsWith("[native code] }")) return `${value.name}:[native]`;
+	return `${value.name}:${source.replace(/\s*\n\s*/g, "")}`;
+}
+//#endregion
+export { serializeFunction };

package/dist/util/serialize/serializeNumber.js

@@ -0,0 +1,21 @@
+//#region src/util/serialize/serializeNumber.ts
+/**
+* Serializes a number into a string.
+*
+* `-0` is serialized as `0`, and `NaN` and `Infinity` are serialized
+* as their string representations.
+*
+* @param value - The number to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeNumber(1); // "1"
+* serializeNumber(-0); // "0"
+* serializeNumber(NaN); // "NaN"
+* serializeNumber(Infinity); // "Infinity"
+*/
+function serializeNumber(value) {
+	return String(value);
+}
+//#endregion
+exports.serializeNumber = serializeNumber;

package/dist/util/serialize/serializeNumber.mjs

@@ -0,0 +1,21 @@
+//#region src/util/serialize/serializeNumber.ts
+/**
+* Serializes a number into a string.
+*
+* `-0` is serialized as `0`, and `NaN` and `Infinity` are serialized
+* as their string representations.
+*
+* @param value - The number to serialize.
+* @returns The serialized string.
+*
+* @example
+* serializeNumber(1); // "1"
+* serializeNumber(-0); // "0"
+* serializeNumber(NaN); // "NaN"
+* serializeNumber(Infinity); // "Infinity"
+*/
+function serializeNumber(value) {
+	return String(value);
+}
+//#endregion
+export { serializeNumber };