@goodbyenjn/utils 26.3.0 → 26.4.0

package/dist/chunks/{chunk-5ed3bc8a.js → chunk-486f65b0.js}

@@ -1,35 +1,8 @@
-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";
+import { i as __toESM, t as __commonJSMin } from "./chunk-7ffde8d4.js";
+import { Dt as isBoolean, Et as isBigInt, Gr as isFunction, Gt as isString, It as isNonNullish, Kt as isSymbol, Nt as isError, Tt as isArray, Vt as isPlainObject, Wr as isPromiseLike, p as clamp, zt as isNumber } from "./chunk-b61db0a7.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) => {
+var require_safe_stable_stringify = __commonJSMin(((exports, module) => {
 	const { hasOwnProperty } = Object.prototype;
 	const stringify = configure();
 	stringify.configure = configure;
@@ -110,7 +83,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 +91,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 +121,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 +130,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 +157,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 +196,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 +204,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 +227,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 +266,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 +346,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 +374,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 +395,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 +408,74 @@ var require_safe_stable_stringify = /* @__PURE__ */ __commonJSMin(((exports, mod
 			}
 			return stringifySimple("", value, []);
 		}
-		return stringify$1;
+		return stringify;
 	}
 }));
 
 //#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);
+var import_safe_stable_stringify = __toESM(require_safe_stable_stringify(), 1);
 const configure = import_safe_stable_stringify.configure;
 
 //#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,174 +485,147 @@ 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(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;
@@ -702,10 +634,7 @@ const err = Result.err;
 //#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}`);
+	return Result.wrap(JSON.parse, Error)(text, reviver).context(`Failed to parse JSON string: ${text.length > 100 ? text.slice(0, 100) + "..." : text}`);
 };
 const unsafeParse = (text, reviver) => {
 	const result = safeParse(text, reviver);
@@ -716,40 +645,32 @@ const unsafeParse = (text, reviver) => {
 //#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(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 = stringify(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;
@@ -764,10 +685,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 = "";
@@ -858,19 +779,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 {
@@ -951,41 +859,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(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 +882,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(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(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,23 +905,23 @@ 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(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));
 	} else return str.replace(/\{(\d+)\}/g, (_, key) => {
@@ -1071,7 +937,7 @@ 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 +945,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;
@@ -1100,4 +966,4 @@ const throttle = (fn, wait = 0, options = {}) => {
 };
 
 //#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 { Result as A, linear as C, safeParse as D, normalizeError as E, ok as M, ResultError as N, stringify as O, 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 };