@goodbyenjn/utils 26.3.0 → 26.4.1

package/dist/chunks/{chunk-5ed3bc8a.js → chunk-11b9216b.js}

@@ -1,35 +1,7 @@
-import { Dr as t, F as isFunction, Fn as e$6, Nn as e$4, On as e, P as isPromiseLike, Pn as e$3, Sn as e$2, Tn as e$8, bn as e$7, gn as e$1, hn as e$5 } from "./chunk-b970a8d0.js";
-
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-//#region node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
-var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+import { a as __toESM, t as __commonJSMin } from "./chunk-3ce2ea14.js";
+import { add, addProp, allPass, anyPass, capitalize, ceil, chunk, clamp, clone, concat, conditional, constant, countBy, debounce as debounce$1, defaultTo, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, endsWith, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isObjectType as isObjectType$1, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString as isString$1, isSymbol, isTruthy, join as join$1, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, mean, meanBy, median, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partialBind, partialLastBind, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, purry, purry as purry$1, randomBigInt, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sliceString, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split as split$1, splitAt, splitWhen, startsWith, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toKebabCase, toLowerCase, toSnakeCase, toTitleCase, toUpperCase, truncate, uncapitalize, unique, uniqueBy, uniqueWith, values, when, zip, zipWith } from "remeda";
+import { accumulateAsync as accumulateP, accumulateSync as accumulate, awaitAll, buffer, chunkAsync as chunkP, compose, concatAsync as concatP, concurrency, differenceAsync as differenceP, differenceByAsync as differenceByP, differenceBySync as differenceBy, differenceWithAsync as differenceWithP, dropAsync as dropP, everyAsync as everyP, everySync as every, executeAsync as executeP, executeSync as execute, filterAsync as filterP, findAsync as findP, flatMapAsync as flatMapP, flattenAsync as flattenP, flattenSync as flatten, forEachAsync as forEachP, intersectionAsync as intersectionP, intersectionByAsync as intersectionByP, intersectionBySync as intersectionBy, intersectionWithAsync as intersectionWithP, mapAsync as mapP, peekAsync as peekP, peekSync as peek, reduceAsync as reduceP, serializeAsync as serializeP, serializeSync as serialize, someAsync as someP, someSync as some, takeAsync as takeP, throttle as throttle$1, toArrayAsync as toArrayP, toArraySync as toArray, toIteratorAsync as toIteratorP, toIteratorSync as toIterator, uniqueAsync as uniqueP, uniqueByAsync as uniqueByP, uniqueWithAsync as uniqueWithP } from "rotery";
+const configure = __toESM(__commonJSMin(((exports, module) => {
 	const { hasOwnProperty } = Object.prototype;
 	const stringify = configure();
 	stringify.configure = configure;
@@ -110,7 +82,7 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 		return `${number} items`;
 	}
 	function getUniqueReplacerSet(replacerArray) {
-		const replacerSet = /* @__PURE__ */ new Set();
+		const replacerSet = new Set();
 		for (const value of replacerArray) if (typeof value === "string" || typeof value === "number") replacerSet.add(String(value));
 		return replacerSet;
 	}
@@ -118,9 +90,9 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 		if (hasOwnProperty.call(options, "strict")) {
 			const value = options.strict;
 			if (typeof value !== "boolean") throw new TypeError("The \"strict\" argument must be of type boolean");
-			if (value) return (value$1) => {
-				let message = `Object can not safely be stringified. Received type ${typeof value$1}`;
-				if (typeof value$1 !== "function") message += ` (${value$1.toString()})`;
+			if (value) return (value) => {
+				let message = `Object can not safely be stringified. Received type ${typeof value}`;
+				if (typeof value !== "function") message += ` (${value.toString()})`;
 				throw new Error(message);
 			};
 		}
@@ -148,7 +120,7 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 					if (value === null) return "null";
 					if (stack.indexOf(value) !== -1) return circularValue;
 					let res = "";
-					let join$1 = ",";
+					let join = ",";
 					const originalIndentation = indentation;
 					if (Array.isArray(value)) {
 						if (value.length === 0) return "[]";
@@ -157,20 +129,20 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 						if (spacer !== "") {
 							indentation += spacer;
 							res += `\n${indentation}`;
-							join$1 = `,\n${indentation}`;
+							join = `,\n${indentation}`;
 						}
 						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
 						let i = 0;
 						for (; i < maximumValuesToStringify - 1; i++) {
-							const tmp$1 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
-							res += tmp$1 !== void 0 ? tmp$1 : "null";
-							res += join$1;
+							const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+							res += tmp !== void 0 ? tmp : "null";
+							res += join;
 						}
 						const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
 						res += tmp !== void 0 ? tmp : "null";
 						if (value.length - 1 > maximumBreadth) {
 							const removedKeys = value.length - maximumBreadth - 1;
-							res += `${join$1}"... ${getItemCount(removedKeys)} not stringified"`;
+							res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
 						}
 						if (spacer !== "") res += `\n${originalIndentation}`;
 						stack.pop();
@@ -184,24 +156,24 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 					let separator = "";
 					if (spacer !== "") {
 						indentation += spacer;
-						join$1 = `,\n${indentation}`;
+						join = `,\n${indentation}`;
 						whitespace = " ";
 					}
 					const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
 					if (deterministic && !isTypedArrayWithEntries(value)) keys = sort(keys, comparator);
 					stack.push(value);
 					for (let i = 0; i < maximumPropertiesToStringify; i++) {
-						const key$1 = keys[i];
-						const tmp = stringifyFnReplacer(key$1, value, stack, replacer, spacer, indentation);
+						const key = keys[i];
+						const tmp = stringifyFnReplacer(key, value, stack, replacer, spacer, indentation);
 						if (tmp !== void 0) {
-							res += `${separator}${strEscape(key$1)}:${whitespace}${tmp}`;
-							separator = join$1;
+							res += `${separator}${strEscape(key)}:${whitespace}${tmp}`;
+							separator = join;
 						}
 					}
 					if (keyLength > maximumBreadth) {
 						const removedKeys = keyLength - maximumBreadth;
 						res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-						separator = join$1;
+						separator = join;
 					}
 					if (spacer !== "" && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
 					stack.pop();
@@ -223,7 +195,7 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 					if (stack.indexOf(value) !== -1) return circularValue;
 					const originalIndentation = indentation;
 					let res = "";
-					let join$1 = ",";
+					let join = ",";
 					if (Array.isArray(value)) {
 						if (value.length === 0) return "[]";
 						if (maximumDepth < stack.length + 1) return "\"[Array]\"";
@@ -231,20 +203,20 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 						if (spacer !== "") {
 							indentation += spacer;
 							res += `\n${indentation}`;
-							join$1 = `,\n${indentation}`;
+							join = `,\n${indentation}`;
 						}
 						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
 						let i = 0;
 						for (; i < maximumValuesToStringify - 1; i++) {
-							const tmp$1 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
-							res += tmp$1 !== void 0 ? tmp$1 : "null";
-							res += join$1;
+							const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+							res += tmp !== void 0 ? tmp : "null";
+							res += join;
 						}
 						const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
 						res += tmp !== void 0 ? tmp : "null";
 						if (value.length - 1 > maximumBreadth) {
 							const removedKeys = value.length - maximumBreadth - 1;
-							res += `${join$1}"... ${getItemCount(removedKeys)} not stringified"`;
+							res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
 						}
 						if (spacer !== "") res += `\n${originalIndentation}`;
 						stack.pop();
@@ -254,15 +226,15 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 					let whitespace = "";
 					if (spacer !== "") {
 						indentation += spacer;
-						join$1 = `,\n${indentation}`;
+						join = `,\n${indentation}`;
 						whitespace = " ";
 					}
 					let separator = "";
-					for (const key$1 of replacer) {
-						const tmp = stringifyArrayReplacer(key$1, value[key$1], stack, replacer, spacer, indentation);
+					for (const key of replacer) {
+						const tmp = stringifyArrayReplacer(key, value[key], stack, replacer, spacer, indentation);
 						if (tmp !== void 0) {
-							res += `${separator}${strEscape(key$1)}:${whitespace}${tmp}`;
-							separator = join$1;
+							res += `${separator}${strEscape(key)}:${whitespace}${tmp}`;
+							separator = join;
 						}
 					}
 					if (spacer !== "" && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
@@ -293,54 +265,54 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 						if (maximumDepth < stack.length + 1) return "\"[Array]\"";
 						stack.push(value);
 						indentation += spacer;
-						let res$1 = `\n${indentation}`;
-						const join$2 = `,\n${indentation}`;
+						let res = `\n${indentation}`;
+						const join = `,\n${indentation}`;
 						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
 						let i = 0;
 						for (; i < maximumValuesToStringify - 1; i++) {
-							const tmp$1 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
-							res$1 += tmp$1 !== void 0 ? tmp$1 : "null";
-							res$1 += join$2;
+							const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+							res += tmp !== void 0 ? tmp : "null";
+							res += join;
 						}
 						const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
-						res$1 += tmp !== void 0 ? tmp : "null";
+						res += tmp !== void 0 ? tmp : "null";
 						if (value.length - 1 > maximumBreadth) {
 							const removedKeys = value.length - maximumBreadth - 1;
-							res$1 += `${join$2}"... ${getItemCount(removedKeys)} not stringified"`;
+							res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
 						}
-						res$1 += `\n${originalIndentation}`;
+						res += `\n${originalIndentation}`;
 						stack.pop();
-						return `[${res$1}]`;
+						return `[${res}]`;
 					}
 					let keys = Object.keys(value);
 					const keyLength = keys.length;
 					if (keyLength === 0) return "{}";
 					if (maximumDepth < stack.length + 1) return "\"[Object]\"";
 					indentation += spacer;
-					const join$1 = `,\n${indentation}`;
+					const join = `,\n${indentation}`;
 					let res = "";
 					let separator = "";
 					let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
 					if (isTypedArrayWithEntries(value)) {
-						res += stringifyTypedArray(value, join$1, maximumBreadth);
+						res += stringifyTypedArray(value, join, maximumBreadth);
 						keys = keys.slice(value.length);
 						maximumPropertiesToStringify -= value.length;
-						separator = join$1;
+						separator = join;
 					}
 					if (deterministic) keys = sort(keys, comparator);
 					stack.push(value);
 					for (let i = 0; i < maximumPropertiesToStringify; i++) {
-						const key$1 = keys[i];
-						const tmp = stringifyIndent(key$1, value[key$1], stack, spacer, indentation);
+						const key = keys[i];
+						const tmp = stringifyIndent(key, value[key], stack, spacer, indentation);
 						if (tmp !== void 0) {
-							res += `${separator}${strEscape(key$1)}: ${tmp}`;
-							separator = join$1;
+							res += `${separator}${strEscape(key)}: ${tmp}`;
+							separator = join;
 						}
 					}
 					if (keyLength > maximumBreadth) {
 						const removedKeys = keyLength - maximumBreadth;
 						res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-						separator = join$1;
+						separator = join;
 					}
 					if (separator !== "") res = `\n${indentation}${res}\n${originalIndentation}`;
 					stack.pop();
@@ -373,8 +345,8 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 						const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
 						let i = 0;
 						for (; i < maximumValuesToStringify - 1; i++) {
-							const tmp$1 = stringifySimple(String(i), value[i], stack);
-							res += tmp$1 !== void 0 ? tmp$1 : "null";
+							const tmp = stringifySimple(String(i), value[i], stack);
+							res += tmp !== void 0 ? tmp : "null";
 							res += ",";
 						}
 						const tmp = stringifySimple(String(i), value[i], stack);
@@ -401,10 +373,10 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 					if (deterministic) keys = sort(keys, comparator);
 					stack.push(value);
 					for (let i = 0; i < maximumPropertiesToStringify; i++) {
-						const key$1 = keys[i];
-						const tmp = stringifySimple(key$1, value[key$1], stack);
+						const key = keys[i];
+						const tmp = stringifySimple(key, value[key], stack);
 						if (tmp !== void 0) {
-							res += `${separator}${strEscape(key$1)}:${tmp}`;
+							res += `${separator}${strEscape(key)}:${tmp}`;
 							separator = ",";
 						}
 					}
@@ -422,7 +394,7 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 				default: return fail ? fail(value) : void 0;
 			}
 		}
-		function stringify$1(value, replacer, space) {
+		function stringify(value, replacer, space) {
 			if (arguments.length > 1) {
 				let spacer = "";
 				if (typeof space === "number") spacer = " ".repeat(Math.min(space, 10));
@@ -435,88 +407,70 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 			}
 			return stringifySimple("", value, []);
 		}
-		return stringify$1;
+		return stringify;
 	}
-}));
-
+}))(), 1).configure;
 //#endregion
-//#region node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
-var import_safe_stable_stringify = /* @__PURE__ */ __toESM(require_safe_stable_stringify(), 1);
-const configure = import_safe_stable_stringify.configure;
-
+//#region src/json/stable.ts
+const stableStringify = configure({ bigint: true });
 //#endregion
 //#region src/result/error.ts
-const prepare = (message, contexts, error) => {
-	let e$9;
-	let emsg;
-	if (e(error)) {
-		e$9 = error;
-		emsg = error.message;
-	} else if (e$1(error) || e$2(error) || e$3(error) || e$4(error) || e$5(error)) emsg = error.toString();
-	else if (error === void 0) emsg = "";
-	else if (error === null) emsg = "null";
-	else emsg = stringify(error);
-	const ctxs = contexts.reverse().concat(emsg || []);
-	let msg = "";
-	if (message) msg = message;
-	else while (ctxs.length > 0) {
-		msg = ctxs.shift();
-		if (msg) break;
-	}
-	const ctx = ctxs.map((line, index) => `    ${index}: ${line}`).join("\n");
-	const display = `
+const prepare = (result, msg) => {
+	const cause = result["error"];
+	const reason = cause === void 0 ? "" : getErrorMessage(cause);
+	const contexts = result["contexts"].reverse().concat(reason || []);
+	let message = "";
+	if (msg) message = msg;
+	else while (contexts.length > 0) {
+		message = contexts.shift();
+		if (message) break;
+	}
+	const ctx = contexts.map((line, index) => `    ${index}: ${line}`).join("\n");
+	const formatted = `
 Message:
-    ${msg || "<empty message>"}
-
+    ${message || "<empty message>"}
 Context:
     ${ctx.trim() || "<empty context>"}
 `.trim();
+	const options = isError(cause) ? { cause } : void 0;
 	return {
-		message: msg,
-		contexts: ctxs,
-		error: e$9,
-		display,
-		options: e$9 ? { cause: e$9 } : void 0
+		message,
+		contexts,
+		formatted,
+		options
 	};
 };
 var ResultError = class ResultError extends Error {
-	static isResultError(value) {
+	static is(value) {
 		return value instanceof ResultError;
 	}
-	#message;
-	#contexts;
-	#display;
-	constructor(message, error, contexts, caller = ResultError) {
-		const prepared = prepare(message, contexts, error);
+	static fmt(result, message) {
+		return prepare(result, message).formatted;
+	}
+	#msg;
+	#ctx;
+	#formatted;
+	constructor(result, message, caller = ResultError) {
+		const prepared = prepare(result, message);
 		super(`
-
-${prepared.display}
-
+--------------------
+${prepared.formatted}
 Stack trace:`, prepared.options);
 		Error.captureStackTrace(this, caller || this.constructor);
-		this.#message = prepared.message;
-		this.#contexts = prepared.contexts;
-		this.#display = prepared.display;
+		this.#msg = prepared.message;
+		this.#ctx = prepared.contexts;
+		this.#formatted = prepared.formatted;
 	}
 	get msg() {
-		return this.#message;
+		return this.#msg;
 	}
-	get ctx() {
-		return this.#contexts.slice();
+	get contexts() {
+		return this.#ctx;
 	}
 	toString() {
-		return this.#display;
+		return this.#formatted;
 	}
 };
-
-//#endregion
-//#region src/result/helper.ts
-function safeTry(body, self) {
-	const yieldErr = body.call(self).next();
-	if (isPromiseLike(yieldErr)) return yieldErr.then((res) => res.value);
-	return yieldErr.value;
-}
-
 //#endregion
 //#region src/result/result.ts
 const never = void 0;
@@ -526,236 +480,208 @@ const transformError = (error, onThrow) => {
 	return onThrow(error);
 };
 var Result = class Result {
+	static is(value) {
+		return value instanceof Result;
+	}
 	static ok(value) {
 		return new Result(true, never, value);
 	}
 	static err(error) {
 		return new Result(false, error, never);
 	}
-	static fromCallable(callable, onThrow) {
+	static try(fnOrPromise, onThrow) {
+		if (!isFunction$1(fnOrPromise) && !isPromiseLike(fnOrPromise)) {
+			const error = new TypeError("Argument must be a function or a promise");
+			return this.err(transformError(error, onThrow));
+		}
+		if (isPromiseLike(fnOrPromise)) return fnOrPromise.then((value) => this.ok(value), (error) => this.err(transformError(error, onThrow)));
 		try {
-			if (!isFunction(callable)) {
-				const error = /* @__PURE__ */ new TypeError("Provided argument is not callable");
-				return this.err(transformError(error, onThrow));
-			}
-			const data = callable();
+			const data = fnOrPromise();
 			if (!isPromiseLike(data)) return this.ok(data);
 			return data.then((value) => this.ok(value), (error) => this.err(transformError(error, onThrow)));
 		} catch (error) {
 			return this.err(transformError(error, onThrow));
 		}
 	}
-	static toSafeCallable(callable, onThrow) {
+	static wrap(fn, onThrow) {
 		return (...args) => {
-			return this.fromCallable(() => callable(...args), onThrow);
+			return this.try(() => fn(...args), onThrow);
 		};
 	}
 	static all(results) {
 		const values = [];
 		for (const result of results) {
-			if (result.isErr()) return this.err(result.#error);
-			values.push(result.#value);
+			if (result.isErr()) return this.err(result.error);
+			values.push(result.value);
 		}
 		return this.ok(values);
 	}
-	#ok;
-	#value;
-	#error;
+	static gen(body, self) {
+		const next = body.call(self).next();
+		const handle = (result) => {
+			if (!result.done) return result.value;
+			return result.value instanceof Result ? result.value : this.ok(result.value);
+		};
+		if (isPromiseLike(next)) return next.then(handle);
+		return handle(next);
+	}
+	ok;
+	value;
+	error;
 	#contexts = [];
-	constructor(ok$1, error, value) {
-		this.#ok = ok$1;
-		this.#error = error;
-		this.#value = value;
+	get contexts() {
+		return this.#contexts;
+	}
+	constructor(ok, error, value) {
+		this.ok = ok;
+		this.error = error;
+		this.value = value;
 	}
-	/**
-	* Check if `Result` is `OK`
-	*/
 	isOk() {
-		return this.#ok;
+		return this.ok;
 	}
-	/**
-	* Check if `Result` is `OK` and the value matches the predicate
-	*/
 	isOkAnd(predicate) {
-		return this.isOk() && predicate(this.#value);
+		return this.isOk() && predicate(this.value);
 	}
-	/**
-	* Check if `Result` is `Err`
-	*/
 	isErr() {
-		return !this.#ok;
+		return !this.ok;
 	}
-	/**
-	* Check if `Result` is `Err` and the error matches the predicate
-	*/
 	isErrAnd(predicate) {
-		return this.isErr() && predicate(this.#error);
+		return this.isErr() && predicate(this.error);
 	}
-	/**
-	* Maps `Result<T, E>` to `Result<U, E>`
-	*/
 	map(fn) {
-		return this.isErr() ? this : Result.ok(fn(this.#value));
+		if (this.isErr()) return this;
+		const result = fn(this.value);
+		return isPromiseLike(result) ? result.then(Result.ok) : Result.ok(result);
 	}
-	/**
-	* Maps `Result<T, E>` to `Result<T, F>`
-	*/
 	mapErr(fn) {
-		return this.isOk() ? this : Result.err(fn(this.#error));
+		if (this.isOk()) return this;
+		const result = fn(this.error);
+		return isPromiseLike(result) ? result.then(Result.err) : Result.err(result);
 	}
 	and(result) {
 		return this.isErr() ? this : result;
 	}
 	andThen(fn) {
-		return this.isErr() ? this : fn(this.#value);
+		return this.isErr() ? this : fn(this.value);
 	}
 	or(result) {
 		return this.isOk() ? this : result;
 	}
 	orElse(fn) {
-		return this.isOk() ? this : fn(this.#error);
+		return this.isOk() ? this : fn(this.error);
 	}
-	/**
-	* Calls the function with the value if `Result` is `Ok` and returns the result unchanged
-	*/
 	inspect(fn) {
 		try {
-			this.isOk() && fn(this.#value);
+			this.isOk() && fn(this.value);
 		} catch {}
 		return this;
 	}
-	/**
-	* Calls the function with the error if `Result` is `Err` and returns the result unchanged
-	*/
 	inspectErr(fn) {
 		try {
-			this.isErr() && fn(this.#error);
+			this.isErr() && fn(this.error);
 		} catch {}
 		return this;
 	}
-	/**
-	* Unwrap the `Ok` value, or throw an error if `Result` is `Err`
-	*/
 	unwrap(message) {
-		if (this.isErr()) throw new ResultError(message !== null ? message ?? "Called unwrap on an Err value" : void 0, this.#error, this.#contexts, this.unwrap);
-		return this.#value;
+		if (this.isErr()) throw new ResultError(this, message !== null ? message ?? "Called `unwrap` on an `Err` value" : void 0, this.unwrap);
+		return this.value;
 	}
-	/**
-	* Unwrap the `Err` value, or throw an error if `Result` is `Ok`
-	*/
 	unwrapErr(message) {
-		if (this.isOk()) throw new ResultError(message !== null ? message ?? "Called unwrapErr on an Ok value" : void 0, this.#error, this.#contexts, this.unwrapErr);
-		return this.#error;
+		if (this.isOk()) throw new ResultError(this, message !== null ? message ?? "Called `unwrapErr` on an `Ok` value" : void 0, this.unwrapErr);
+		return this.error;
 	}
-	/**
-	* Unwrap the `Ok` value, or return the provided value if `Result` is `Err`
-	*/
 	unwrapOr(defaultValue) {
-		return this.isOk() ? this.#value : defaultValue;
+		return this.isOk() ? this.value : defaultValue;
 	}
-	/**
-	* Unwrap the `Ok` value, or compute it from a function if `Result` is `Err`
-	*/
 	unwrapOrElse(defaultValueGetter) {
-		return this.isOk() ? this.#value : defaultValueGetter(this.#error);
+		return this.isOk() ? this.value : defaultValueGetter(this.error);
 	}
-	/**
-	* Matches the `Result` variant and executes the corresponding function
-	*/
-	match(ok$1, err$1) {
-		return this.isOk() ? ok$1(this.#value) : err$1(this.#error);
+	match(ok, err) {
+		return this.isOk() ? ok(this.value) : err(this.error);
 	}
-	/**
-	* Returns an iterable object that yields the `Ok` value and `Err` value
-	*/
 	iter() {
 		if (this.isOk()) return [
 			true,
 			never,
-			this.#value
+			this.value
 		];
 		else return [
 			false,
-			this.#error,
+			this.error,
 			never
 		];
 	}
 	*[Symbol.iterator]() {
-		if (this.isOk()) return this.#value;
-		const self = this;
-		yield self;
-		return self;
+		if (this.isOk()) return this.value;
+		yield this;
+		return this;
 	}
 	context(context) {
 		this.#contexts.push(context);
 		return this;
 	}
-	toString() {
-		if (this.isErr()) return new ResultError(void 0, this.#error, this.#contexts).toString();
-		return `Ok(${stringify(this.#value)})`;
-	}
 };
 const ok = Result.ok;
 const err = Result.err;
-
+const isResult = Result.is;
 //#endregion
-//#region src/common/json.ts
-const stringify = configure({ bigint: true });
-const safeParse = (text, reviver) => {
-	const fn = () => {
-		return JSON.parse(text, reviver);
-	};
-	return Result.fromCallable(fn, Error).context(`Failed to parse JSON string: ${text.length > 100 ? text.slice(0, 100) + "..." : text}`);
-};
-const unsafeParse = (text, reviver) => {
-	const result = safeParse(text, reviver);
-	if (result.isErr()) return void 0;
-	return result.unwrap(null);
-};
-
+//#region src/remeda/hasOwnProperty.ts
+function hasOwnProperty(...args) {
+	return purry(hasOwnPropertyImplementation, args);
+}
+function hasOwnPropertyImplementation(data, properties) {
+	if (!isObjectType(data)) return false;
+	for (const property of properties) if (!Object.hasOwn(data, property)) return false;
+	return true;
+}
+//#endregion
+//#region src/remeda/isFunction.ts
+function isFunction$1(data) {
+	return typeof data === "function";
+}
+//#endregion
+//#region src/remeda/isPromiseLike.ts
+function isPromiseLike(data) {
+	return isObjectType(data) && isFunction(data.then) && Object.getOwnPropertyDescriptor(data, "then")?.get === void 0;
+}
 //#endregion
 //#region src/common/error.ts
 const normalizeError = (error, caller) => {
-	if (e(error)) return error;
-	let message;
-	if (e$1(error) || e$2(error) || e$3(error) || e$4(error) || e$5(error)) message = error.toString();
-	else if (error === void 0) message = "undefined";
-	else if (error === null) message = "null";
-	else message = stringify(error);
-	const e$9 = new Error(message);
-	Error.captureStackTrace(e$9, caller || normalizeError);
-	return e$9;
+	if (isError(error)) return error;
+	const e = new Error(getErrorMessage(error));
+	Error.captureStackTrace(e, caller || normalizeError);
+	return e;
+};
+const getErrorMessage = (error, message) => {
+	if (isError(error)) return error.message;
+	if (message !== void 0) return message;
+	let msg;
+	if (isString$1(error) || isNumber(error) || isBigInt(error) || isBoolean(error) || isSymbol(error)) msg = error.toString();
+	else if (error === void 0) msg = "undefined";
+	else if (error === null) msg = "null";
+	else msg = stableStringify(error);
+	return msg;
 };
-const getErrorMessage = (error, message = "Unknown error") => error instanceof Error ? error.message : message;
-
 //#endregion
 //#region src/common/math.ts
-/**
-* @example
-* ```
-* const value = linear(0.5, [0, 2]) // value: 1
-* ```
-*/
 const linear = (value, range) => {
 	const [min, max] = range;
-	const interpolation = t(value, {
+	const interpolation = clamp(value, {
 		min: 0,
 		max: 1
 	});
 	return min + (max - min) * interpolation;
 };
-/**
-* @example
-* ```
-* const value = scale(0.5, [0, 1], [200, 400]) // value: 300
-* ```
-*/
 const scale = (value, inRange, outRange) => {
 	const [inMin, inMax] = inRange;
 	const [outMin, outMax] = outRange;
 	return linear((value - inMin) / (inMax - inMin), [outMin, outMax]);
 };
-
+//#endregion
+//#region src/common/nil.ts
+const nil = Symbol("nil");
+const isNil = (value) => value === nil;
 //#endregion
 //#region src/common/parse.ts
 const parseKey = (input, raw = input) => {
@@ -764,10 +690,10 @@ const parseKey = (input, raw = input) => {
 		end: 0
 	};
 	else if (/^\s/.test(input)) {
-		const { value: value$1, end: end$1 } = parseKey(input.slice(1), raw);
+		const { value, end } = parseKey(input.slice(1), raw);
 		return {
-			value: value$1,
-			end: end$1 + 1
+			value,
+			end: end + 1
 		};
 	}
 	let value = "";
@@ -836,7 +762,6 @@ const parseValueToBoolean = (value, defaultValue) => {
 	if (/^(?:n|no|false|0|off)$/.test(str)) return false;
 	return defaultValue;
 };
-
 //#endregion
 //#region src/common/promise.ts
 const sleep = (ms, callback) => new Promise((resolve) => {
@@ -858,19 +783,6 @@ const createSingleton = (fn) => {
 	};
 	return wrapper;
 };
-/**
-* @example
-* ```
-* const lock = createLock()
-*
-* lock.run(async () => {
-*   await doSomething()
-* })
-*
-* // in anther context:
-* await lock.wait() // it will wait all tasking finished
-* ```
-*/
 const createLock = () => {
 	const locks = [];
 	return {
@@ -896,7 +808,7 @@ const createLock = () => {
 	};
 };
 const createPromiseWithResolvers = () => {
-	if (isFunction(Promise.withResolvers)) return Promise.withResolvers();
+	if (isFunction$1(Promise.withResolvers)) return Promise.withResolvers();
 	let resolve;
 	let reject;
 	return {
@@ -908,7 +820,6 @@ const createPromiseWithResolvers = () => {
 		reject
 	};
 };
-
 //#endregion
 //#region src/common/string.ts
 const REGEXP_WHITESPACE_ONLY = /^\s*$/;
@@ -951,41 +862,20 @@ const toForwardSlash = (str) => str.replace(/\\/g, "/");
 const joinWithSlash = (...paths) => join("/", ...paths);
 const splitWithSlash = (path) => split("/", path);
 const splitByLineBreak = (str) => str.split(/\r?\n/);
-const concatTemplateStrings = (template$1, values) => template$1.reduce((acc, part, index) => acc + part + (values[index] ?? ""), "");
-/**
-* @example
-* ```ts
-* // Default behavior: trim both start and end
-* const str1 = unindent`
-*   if (a) {
-*     b()
-*   }
-* `;
-*
-* // Factory function: custom trim behavior
-* const str2 = unindent(false, false)`
-*   if (a) {
-*     b()
-*   }
-* `;
-*
-* // Only trim start, keep end
-* const str3 = unindent(true, false)("  hello\n  world\n");
-* ```
-*/
-const unindent = (...params) => {
+const concatTemplateStrings = (template, values) => template.reduce((acc, part, index) => acc + part + (values[index] ?? ""), "");
+function unindent(...params) {
 	let trimStart = true;
 	let trimEnd = true;
-	const unindentImpl = (...params$1) => {
-		const lines = splitByLineBreak(e$1(params$1[0]) ? params$1[0] : concatTemplateStrings(params$1[0], params$1.slice(1)));
+	const unindentImpl = (...params) => {
+		const lines = splitByLineBreak(isString$1(params[0]) ? params[0] : concatTemplateStrings(params[0], params.slice(1)));
 		let commonIndent = Number.POSITIVE_INFINITY;
 		let firstContentLine = -1;
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
 			if (REGEXP_WHITESPACE_ONLY.test(line)) continue;
 			if (firstContentLine === -1) firstContentLine = i;
-			const indent$1 = line.match(REGEXP_WHITESPACE_PREFIX)?.[0].length ?? 0;
-			commonIndent = Math.min(commonIndent, indent$1);
+			const indent = line.match(REGEXP_WHITESPACE_PREFIX)?.[0].length ?? 0;
+			commonIndent = Math.min(commonIndent, indent);
 		}
 		if (firstContentLine === -1) commonIndent = 0;
 		if (!Number.isFinite(commonIndent)) commonIndent = 0;
@@ -995,41 +885,20 @@ const unindent = (...params) => {
 		if (trimEnd) while (endIndex > startIndex && REGEXP_WHITESPACE_ONLY.test(lines[endIndex - 1])) endIndex--;
 		return lines.slice(startIndex, endIndex).map((line) => line.slice(commonIndent)).join("\n");
 	};
-	if ((e$4(params[0]) || params[0] === void 0) && (e$4(params[1]) || params[1] === void 0)) {
+	if ((isBoolean(params[0]) || params[0] === void 0) && (isBoolean(params[1]) || params[1] === void 0)) {
 		trimStart = params[0] !== false;
 		trimEnd = params[1] !== false;
 		return unindentImpl;
 	}
-	if (e$1(params[0]) || e$6(params[0])) return unindentImpl(...params);
+	if (isString$1(params[0]) || isArray(params[0])) return unindentImpl(...params);
 	throw new TypeError(`First parameter has an invalid type: "${typeof params[0]}"`);
-};
-/**
-* @example
-* ```ts
-* // Using indent count with default space character
-* const str1 = indent(2)`
-*   if (a) {
-*     b()
-*   }
-* `;
-*
-* // Using custom indent string directly
-* const str2 = indent(">>")`
-*   if (a) {
-*     b()
-*   }
-* `;
-*
-* // Only trim start, keep end
-* const str3 = indent(2, true, false)("hello\nworld\n");
-* ```
-*/
-const indent = (...params) => {
+}
+function indent(...params) {
 	let indentString;
 	let trimStart = true;
 	let trimEnd = true;
-	const indentImpl = (...params$1) => {
-		const lines = splitByLineBreak(e$1(params$1[0]) ? params$1[0] : concatTemplateStrings(params$1[0], params$1.slice(1)));
+	const indentImpl = (...params) => {
+		const lines = splitByLineBreak(isString$1(params[0]) ? params[0] : concatTemplateStrings(params[0], params.slice(1)));
 		const whitespaceLines = lines.map((line) => REGEXP_WHITESPACE_ONLY.test(line));
 		let startIndex = 0;
 		let endIndex = lines.length;
@@ -1039,39 +908,38 @@ const indent = (...params) => {
 			return whitespaceLines[index + startIndex] ? line : indentString + line;
 		}).join("\n");
 	};
-	if ((e$4(params[1]) || params[1] === void 0) && (e$4(params[2]) || params[2] === void 0)) {
+	if ((isBoolean(params[1]) || params[1] === void 0) && (isBoolean(params[2]) || params[2] === void 0)) {
 		trimStart = params[1] !== false;
 		trimEnd = params[2] !== false;
 	}
-	if (e$2(params[0])) {
+	if (isNumber(params[0])) {
 		indentString = " ".repeat(params[0]);
 		return indentImpl;
 	}
-	if (e$1(params[0])) {
+	if (isString$1(params[0])) {
 		indentString = params[0];
 		return indentImpl;
 	}
 	throw new TypeError(`First parameter has an invalid type: "${typeof params[0]}"`);
-};
+}
 function template(str, ...args) {
 	const [firstArg, fallback] = args;
-	if (e$7(firstArg)) {
+	if (isPlainObject(firstArg)) {
 		const mapping = firstArg;
-		return str.replace(/\{(\w+)\}/g, (_, key) => mapping[key] || ((isFunction(fallback) ? fallback(key) : fallback) ?? key));
+		return str.replace(/\{(\w+)\}/g, (_, key) => mapping[key] || ((isFunction$1(fallback) ? fallback(key) : fallback) ?? key));
 	} else return str.replace(/\{(\d+)\}/g, (_, key) => {
 		const index = Number(key);
 		if (Number.isNaN(index)) return key;
 		return args[index];
 	});
 }
-
 //#endregion
 //#region src/common/throttle.ts
 const wrap = (fn, wait, options) => {
 	const { leading, trailing } = options;
 	let timerId;
 	const wrapped = (...args) => {
-		if (e$8(timerId)) return;
+		if (isNonNullish(timerId)) return;
 		timerId = globalThis.setTimeout(() => {
 			timerId = void 0;
 			trailing && fn(...args);
@@ -1079,7 +947,7 @@ const wrap = (fn, wait, options) => {
 		leading && fn(...args);
 	};
 	wrapped.cancel = () => {
-		if (e$8(timerId)) globalThis.clearTimeout(timerId);
+		if (isNonNullish(timerId)) globalThis.clearTimeout(timerId);
 		timerId = void 0;
 	};
 	return wrapped;
@@ -1098,6 +966,5 @@ const throttle = (fn, wait = 0, options = {}) => {
 		trailing
 	});
 };
-
 //#endregion
-export { Result as A, linear as C, safeParse as D, normalizeError as E, __commonJSMin as F, __toESM as I, ok as M, safeTry as N, stringify as O, ResultError as P, parseValueToBoolean as S, getErrorMessage as T, createLock as _, concatTemplateStrings as a, sleep as b, joinWithSlash as c, split as d, splitByLineBreak as f, unindent as g, toForwardSlash as h, addSuffix as i, err as j, unsafeParse as k, removePrefix as l, template as m, throttle as n, indent as o, splitWithSlash as p, addPrefix as r, join as s, debounce as t, removeSuffix as u, createPromiseWithResolvers as v, scale as w, parseKeyValuePairs as x, createSingleton as y };
+export { differenceBy as $, pipe as $n, toIterator as $r, isArray as $t, accumulateP as A, mapValues as An, splice as Ar, flatMapP as At, chunkP as B, objOf as Bn, swapProps as Br, groupBy as Bt, isNil as C, isResult as Ci, keys as Cn, sort as Cr, findLast as Ct, getErrorMessage as D, mapKeys as Dn, sortedIndexWith as Dr, firstBy as Dt, scale as E, stableStringify as Ei, map as En, sortedIndexBy as Er, first as Et, awaitAll as F, merge as Fn, stringToPath as Fr, forEachObj as Ft, concatP as G, partialBind as Gn, takeP as Gr, indexBy as Gt, clone as H, omitBy as Hn, takeFirstBy as Hr, hasAtLeast as Ht, buffer as I, mergeAll as In, subtract as Ir, forEachP as It, constant as J, pathOr as Jn, throttle$1 as Jr, intersectionByP as Jt, concurrency as K, partialLastBind as Kn, takeWhile as Kr, intersection as Kt, capitalize as L, mergeDeep as Ln, sum as Lr, fromEntries as Lt, addProp as M, mean as Mn, splitAt as Mr, flattenP as Mt, allPass as N, meanBy as Nn, splitWhen as Nr, floor as Nt, normalizeError as O, mapP as On, sortedLastIndex as Or, flat as Ot, anyPass as P, median as Pn, startsWith as Pr, forEach as Pt, difference as Q, pickBy as Qn, toCamelCase as Qr, invert as Qt, ceil as R, multiply as Rn, sumBy as Rr, fromKeys as Rt, parseValueToBoolean as S, err as Si, join$1 as Sn, someP as Sr, findIndex as St, linear as T, ResultError as Ti, length as Tn, sortedIndex as Tr, findP as Tt, compose as U, once as Un, takeLast as Ur, hasSubObject as Ut, clamp as V, omit as Vn, take as Vr, groupByProp as Vt, concat as W, only as Wn, takeLastWhile as Wr, identity as Wt, debounce$1 as X, peekP as Xn, toArray as Xr, intersectionWith as Xt, countBy as Y, peek as Yn, times as Yr, intersectionP as Yt, defaultTo as Z, pick as Zn, toArrayP as Zr, intersectionWithP as Zt, createLock as _, zipWith as _i, isShallowEqual as _n, set as _r, execute as _t, concatTemplateStrings as a, toUpperCase as ai, isEmpty as an, randomBigInt as ar, doNothing as at, sleep as b, hasOwnProperty as bi, isSymbol as bn, sliceString as br, filterP as bt, joinWithSlash as c, unique as ci, isIncludedIn as cn, range as cr, dropLast as ct, split as d, uniqueP as di, isNot as dn, reduceP as dr, dropWhile as dt, toIteratorP as ei, isBigInt as en, piped as er, differenceByP as et, splitByLineBreak as f, uniqueWith as fi, isNullish as fn, reverse as fr, endsWith as ft, unindent as g, zip as gi, isPromise as gn, serializeP as gr, evolve as gt, toForwardSlash as h, when as hi, isPlainObject as hn, serialize as hr, everyP as ht, addSuffix as i, toTitleCase as ii, isDefined as in, purry$1 as ir, divide as it, add as j, mapWithFeedback as jn, split$1 as jr, flatten as jt, accumulate as k, mapToObj as kn, sortedLastIndexBy as kr, flatMap as kt, removePrefix as l, uniqueBy as li, isNonNull as ln, rankBy as lr, dropLastWhile as lt, template as m, values as mi, isObjectType$1 as mn, sample as mr, every as mt, throttle as n, toLowerCase as ni, isDate as nn, prop as nr, differenceWith as nt, indent as o, truncate as oi, isEmptyish as on, randomInteger as or, drop as ot, splitWithSlash as p, uniqueWithP as pi, isNumber as pn, round as pr, entries as pt, conditional as q, partition as qn, tap as qr, intersectionBy as qt, addPrefix as r, toSnakeCase as ri, isDeepEqual as rn, pullObject as rr, differenceWithP as rt, join as s, uncapitalize as si, isError as sn, randomString as sr, dropFirstBy as st, debounce as t, toKebabCase as ti, isBoolean as tn, product as tr, differenceP as tt, removeSuffix as u, uniqueByP as ui, isNonNullish as un, reduce as ur, dropP as ut, createPromiseWithResolvers as v, isPromiseLike as vi, isStrictEqual as vn, setPath as vr, executeP as vt, nil as w, ok as wi, last as wn, sortBy as wr, findLastIndex as wt, parseKeyValuePairs as x, Result as xi, isTruthy as xn, some as xr, find as xt, createSingleton as y, isFunction$1 as yi, isString$1 as yn, shuffle as yr, filter as yt, chunk as z, nthBy as zn, swapIndices as zr, funnel as zt };