@goodbyenjn/utils 1.2.0 → 1.3.0

package/dist/fs.d.ts

@@ -1,5 +1,5 @@
-import "./libs/types-4042b7e8.js";
-import { Result, ResultAsync } from "./libs/result-81665e58.js";
+import "./libs/types-92e74e19.js";
+import { Result } from "./libs/result-4e97f1e0.js";
 
 //#region src/fs/types.d.ts
 type PathLike = string | URL;
@@ -27,26 +27,26 @@ interface CpOptions {
 }
 //#endregion
 //#region src/fs/safe.d.ts
-declare const appendFile$1: (path: PathLike, data: string, options?: AppendFileOptions) => ResultAsync<void, string>;
+declare const appendFile$1: (path: PathLike, data: string, options?: AppendFileOptions) => Promise<Result<void, string>>;
 declare const appendFileSync$1: (path: PathLike, data: string, options?: AppendFileOptions) => Result<void, string>;
-declare const cp$1: (source: PathLike, destination: PathLike, options?: CpOptions) => ResultAsync<void, string>;
+declare const cp$1: (source: PathLike, destination: PathLike, options?: CpOptions) => Promise<Result<void, string>>;
 declare const cpSync$1: (source: PathLike, destination: PathLike, options?: CpOptions) => Result<void, string>;
-declare const exists$1: (path: PathLike) => ResultAsync<true, string>;
+declare const exists$1: (path: PathLike) => Promise<Result<true, string>>;
 declare const existsSync$1: (path: PathLike) => Result<true, string>;
-declare const mkdir$1: (path: PathLike, options?: MkdirOptions) => ResultAsync<void, string>;
+declare const mkdir$1: (path: PathLike, options?: MkdirOptions) => Promise<Result<void, string>>;
 declare const mkdirSync$1: (path: PathLike, options?: MkdirOptions) => Result<void, string>;
-declare function readFile$1(path: PathLike, options: BufferEncodingOptions): ResultAsync<Buffer, string>;
-declare function readFile$1(path: PathLike, options?: StringEncodingOptions): ResultAsync<string, string>;
+declare function readFile$1(path: PathLike, options: BufferEncodingOptions): Promise<Result<Buffer, string>>;
+declare function readFile$1(path: PathLike, options?: StringEncodingOptions): Promise<Result<string, string>>;
 declare function readFileSync$1(path: PathLike, options: BufferEncodingOptions): Result<Buffer, string>;
 declare function readFileSync$1(path: PathLike, options?: StringEncodingOptions): Result<string, string>;
-declare const readFileByLine$1: (path: PathLike, options?: StringEncodingOptions) => ResultAsync<AsyncIterator<string>, string>;
-declare const readJson$1: <T = any>(path: PathLike, options?: StringEncodingOptions) => ResultAsync<T, string>;
+declare const readFileByLine$1: (path: PathLike, options?: StringEncodingOptions) => Promise<Result<AsyncIterator<string>, string>>;
+declare const readJson$1: <T = any>(path: PathLike, options?: StringEncodingOptions) => Promise<Result<T, string>>;
 declare const readJsonSync$1: <T = any>(path: PathLike, options?: StringEncodingOptions) => Result<T, string>;
-declare const rm$1: (path: PathLike, options?: RmOptions) => ResultAsync<void, string>;
+declare const rm$1: (path: PathLike, options?: RmOptions) => Promise<Result<void, string>>;
 declare const rmSync$1: (path: PathLike, options?: RmOptions) => Result<void, string>;
-declare const writeFile: (path: PathLike, data: string, options?: StringEncodingOptions) => ResultAsync<void, string>;
+declare const writeFile: (path: PathLike, data: string, options?: StringEncodingOptions) => Promise<Result<void, string>>;
 declare const writeFileSync: (path: PathLike, data: string, options?: StringEncodingOptions) => Result<void, string>;
-declare const writeJson: (path: PathLike, data: any, indentOrOptions?: WriteJsonOptions) => ResultAsync<void, string>;
+declare const writeJson: (path: PathLike, data: any, indentOrOptions?: WriteJsonOptions) => Promise<Result<void, string>>;
 declare const writeJsonSync: (path: PathLike, data: any, indentOrOptions?: WriteJsonOptions) => Result<void, string>;
 //#endregion
 //#region src/fs/unsafe.d.ts
@@ -79,7 +79,7 @@ interface VFileOptions {
   cwd?: string | undefined;
 }
 declare class VFile {
-  static fromFilepath(pathname: string, cwd?: string): ResultAsync<VFile, string>;
+  static fromFilepath(pathname: string, cwd?: string): any;
   content: string;
   /**
    * @example

package/dist/fs.js

@@ -1,6 +1,6 @@
 import { e$3 as e } from "./libs/remeda-662cc9ef.js";
-import { errorToMessage, removePrefix } from "./libs/common-7de47aac.js";
-import { Result, ResultAsync, err, ok, safeTry } from "./libs/result-6175a096.js";
+import { errorToMessage, removePrefix } from "./libs/common-ca6da438.js";
+import { Result, err, ok, safeTry } from "./libs/result-1bfb809c.js";
 import fs, { promises } from "node:fs";
 import path, { dirname } from "node:path";
 
@@ -20,63 +20,108 @@ const parseWriteJsonOptions = (options) => {
 		encoding: parseEncodingOptions(options)
 	};
 };
-const appendFile$1 = (path$1, data, options) => safeTry(async function* () {
+const appendFile$1 = async (path$1, data, options) => safeTry(async function* () {
 	const newline = options?.newline ?? true;
-	yield* mkdir$1(dirname(pathLikeToPath(path$1).toString()));
-	const fn = ResultAsync.fromThrowable(promises.appendFile, errorToMessage(`Failed to append file: ${path$1}`));
-	const result = fn(path$1, newline ? `\n${data}` : data, parseEncodingOptions(options));
+	yield* await mkdir$1(dirname(pathLikeToPath(path$1).toString()));
+	const fn = async () => {
+		await promises.appendFile(path$1, newline ? `\n${data}` : data, parseEncodingOptions(options));
+	};
+	const onThrow = errorToMessage(`Failed to append file: ${path$1}`);
+	const result = await Result.try(fn, onThrow);
 	return result;
 });
 const appendFileSync$1 = (path$1, data, options) => safeTry(function* () {
 	const newline = options?.newline ?? true;
 	yield* mkdirSync$1(dirname(pathLikeToPath(path$1).toString()));
-	const fn = Result.fromThrowable(fs.appendFileSync, errorToMessage(`Failed to append file: ${path$1}`));
-	const result = fn(path$1, newline ? `\n${data}` : data, parseEncodingOptions(options));
+	const fn = () => {
+		fs.appendFileSync(path$1, newline ? `\n${data}` : data, parseEncodingOptions(options));
+	};
+	const onThrow = errorToMessage(`Failed to append file: ${path$1}`);
+	const result = Result.try(fn, onThrow);
 	return result;
 });
-const cp$1 = (source, destination, options) => {
+const cp$1 = async (source, destination, options) => {
 	const { recursive = true } = options || {};
-	const fn = ResultAsync.fromThrowable(promises.cp, errorToMessage(`Failed to copy path: ${source} to ${destination}`));
-	const result = fn(source, destination, { recursive });
+	const fn = async () => {
+		await promises.cp(source, destination, { recursive });
+	};
+	const onThrow = errorToMessage(`Failed to copy path: ${source} to ${destination}`);
+	const result = await Result.try(fn, onThrow);
 	return result;
 };
 const cpSync$1 = (source, destination, options) => {
 	const { recursive = true } = options || {};
-	const fn = Result.fromThrowable(fs.cpSync, errorToMessage(`Failed to copy path: ${source} to ${destination}`));
-	const result = fn(source, destination, { recursive });
+	const fn = () => {
+		fs.cpSync(source, destination, { recursive });
+	};
+	const onThrow = errorToMessage(`Failed to copy path: ${source} to ${destination}`);
+	const result = Result.try(fn, onThrow);
 	return result;
 };
-const exists$1 = (path$1) => {
-	const fn = ResultAsync.fromThrowable(promises.access, errorToMessage(`Failed to check exists of path: ${path$1}`));
-	const result = fn(path$1);
-	return result.map(() => true);
+const exists$1 = async (path$1) => {
+	const fn = async () => {
+		await promises.access(path$1);
+		return true;
+	};
+	const onThrow = errorToMessage(`Failed to check exists of path: ${path$1}`);
+	const result = await Result.try(fn, onThrow);
+	return result;
 };
 const existsSync$1 = (path$1) => {
-	const fn = Result.fromThrowable(fs.accessSync, errorToMessage(`Failed to check exists of path: ${path$1}`));
-	const result = fn(path$1);
-	return result.map(() => true);
+	const fn = () => {
+		fs.accessSync(path$1);
+		return true;
+	};
+	const onThrow = errorToMessage(`Failed to check exists of path: ${path$1}`);
+	const result = Result.try(fn, onThrow);
+	return result;
 };
-const mkdir$1 = (path$1, options) => {
+const mkdir$1 = async (path$1, options) => {
 	const { recursive = true } = options || {};
-	const fn = ResultAsync.fromThrowable(() => promises.mkdir(path$1, { recursive }), errorToMessage(`Failed to create directory: ${path$1}`));
-	return exists$1(path$1).and(ok()).or(fn());
+	if ((await exists$1(path$1)).isOk()) return ok();
+	const fn = async () => {
+		await promises.mkdir(path$1, { recursive });
+	};
+	const onThrow = errorToMessage(`Failed to create directory: ${path$1}`);
+	const result = await Result.try(fn, onThrow);
+	return result;
 };
 const mkdirSync$1 = (path$1, options) => {
 	const { recursive = true } = options || {};
-	const fn = Result.fromThrowable(() => fs.mkdirSync(path$1, { recursive }), errorToMessage(`Failed to create directory: ${path$1}`));
-	return existsSync$1(path$1).and(ok()).or(fn());
+	if (existsSync$1(path$1).isOk()) return ok();
+	const fn = () => {
+		fs.mkdirSync(path$1, { recursive });
+	};
+	const onThrow = errorToMessage(`Failed to create directory: ${path$1}`);
+	const result = Result.try(fn, onThrow);
+	return result;
 };
-function readFile$1(path$1, options) {
-	const fn = ResultAsync.fromThrowable(() => promises.readFile(path$1, parseEncodingOptions(options)), errorToMessage(`Failed to read file: ${path$1}`));
-	return exists$1(path$1).and(fn());
+async function readFile$1(path$1, options) {
+	return safeTry(async function* () {
+		yield* await exists$1(path$1);
+		const fn = async () => {
+			return await promises.readFile(path$1, parseEncodingOptions(options));
+		};
+		const onThrow = errorToMessage(`Failed to read file: ${path$1}`);
+		const result = await Result.try(fn, onThrow);
+		return result;
+	});
 }
 function readFileSync$1(path$1, options) {
-	const fn = Result.fromThrowable(() => fs.readFileSync(path$1, parseEncodingOptions(options)), errorToMessage(`Failed to read file: ${path$1}`));
-	return existsSync$1(path$1).and(fn());
+	return safeTry(function* () {
+		yield* existsSync$1(path$1);
+		const fn = () => {
+			return fs.readFileSync(path$1, parseEncodingOptions(options));
+		};
+		const onThrow = errorToMessage(`Failed to read file: ${path$1}`);
+		const result = Result.try(fn, onThrow);
+		return result;
+	});
 }
-const readFileByLine$1 = (path$1, options) => {
-	const reader = async () => {
-		const { createInterface } = await import("node:readline");
+const readFileByLine$1 = async (path$1, options) => safeTry(async function* () {
+	yield* await exists$1(path$1);
+	const { createInterface } = await import("node:readline");
+	const fn = () => {
 		const stream = fs.createReadStream(path$1, {
 			...parseEncodingOptions(options),
 			autoClose: true
@@ -84,58 +129,78 @@ const readFileByLine$1 = (path$1, options) => {
 		stream.on("error", (error) => {
 			throw error;
 		});
-		const reader$1 = createInterface({
+		const reader = createInterface({
 			input: stream,
 			crlfDelay: Infinity
 		});
-		return reader$1[Symbol.asyncIterator]();
+		return reader[Symbol.asyncIterator]();
 	};
-	const fn = ResultAsync.fromThrowable(reader, errorToMessage(`Failed to read file: ${path$1}`));
-	return exists$1(path$1).and(fn());
-};
-const readJson$1 = (path$1, options) => {
-	const fn = Result.fromThrowable(JSON.parse, errorToMessage(`Failed to parse JSON file: ${path$1}`));
-	return readFile$1(path$1, options).andThen((content) => {
-		if (!content) return err(`JSON file is empty: ${path$1}`);
-		const result = fn(content);
-		return result;
-	});
-};
-const readJsonSync$1 = (path$1, options) => {
-	const fn = Result.fromThrowable(JSON.parse, errorToMessage(`Failed to parse JSON file: ${path$1}`));
-	return readFileSync$1(path$1, options).andThen((content) => {
-		if (!content) return err(`JSON file is empty: ${path$1}`);
-		const result = fn(content);
-		return result;
-	});
-};
-const rm$1 = (path$1, options) => {
+	const onThrow = errorToMessage(`Failed to read file: ${path$1}`);
+	const result = Result.try(fn, onThrow);
+	return result;
+});
+const readJson$1 = async (path$1, options) => safeTry(async function* () {
+	const content = yield* await readFile$1(path$1, options);
+	if (!content) return err(`JSON file is empty: ${path$1}`);
+	const fn = () => {
+		return JSON.parse(content);
+	};
+	const onThrow = errorToMessage(`Failed to parse JSON file: ${path$1}`);
+	const result = Result.try(fn, onThrow);
+	return result;
+});
+const readJsonSync$1 = (path$1, options) => safeTry(function* () {
+	const content = yield* readFileSync$1(path$1, options);
+	if (!content) return err(`JSON file is empty: ${path$1}`);
+	const fn = () => {
+		return JSON.parse(content);
+	};
+	const onThrow = errorToMessage(`Failed to parse JSON file: ${path$1}`);
+	const result = Result.try(fn, onThrow);
+	return result;
+});
+const rm$1 = async (path$1, options) => {
 	const { force = true, recursive = true } = options || {};
-	const fn = ResultAsync.fromThrowable(promises.rm, errorToMessage(`Failed to remove path: ${path$1}`));
-	const result = fn(path$1, {
-		force,
-		recursive
-	});
+	const fn = async () => {
+		await promises.rm(path$1, {
+			force,
+			recursive
+		});
+	};
+	const onThrow = errorToMessage(`Failed to remove path: ${path$1}`);
+	const result = await Result.try(fn, onThrow);
 	return result;
 };
 const rmSync$1 = (path$1, options) => {
 	const { force = true, recursive = true } = options || {};
-	const fn = Result.fromThrowable(fs.rmSync, errorToMessage(`Failed to remove path: ${path$1}`));
-	const result = fn(path$1, {
-		force,
-		recursive
-	});
+	const fn = () => {
+		fs.rmSync(path$1, {
+			force,
+			recursive
+		});
+	};
+	const onThrow = errorToMessage(`Failed to remove path: ${path$1}`);
+	const result = Result.try(fn, onThrow);
 	return result;
 };
-const writeFile = (path$1, data, options) => {
-	const fn = ResultAsync.fromThrowable(promises.writeFile, errorToMessage(`Failed to write file: ${path$1}`));
-	return mkdir$1(dirname(pathLikeToPath(path$1).toString())).and(fn(path$1, data, parseEncodingOptions(options)));
-};
+const writeFile = async (path$1, data, options) => safeTry(async function* () {
+	yield* await mkdir$1(dirname(pathLikeToPath(path$1).toString()));
+	const fn = async () => {
+		await promises.writeFile(path$1, data, parseEncodingOptions(options));
+	};
+	const onThrow = errorToMessage(`Failed to write file: ${path$1}`);
+	const result = await Result.try(fn, onThrow);
+	return result;
+});
 const writeFileSync = (path$1, data, options) => {
-	const fn = Result.fromThrowable(fs.writeFileSync, errorToMessage(`Failed to write file: ${path$1}`));
-	return mkdirSync$1(dirname(pathLikeToPath(path$1).toString())).and(fn(path$1, data, parseEncodingOptions(options)));
+	const fn = () => {
+		fs.writeFileSync(path$1, data, parseEncodingOptions(options));
+	};
+	const onThrow = errorToMessage(`Failed to write file: ${path$1}`);
+	const result = Result.try(fn, onThrow);
+	return result;
 };
-const writeJson = (path$1, data, indentOrOptions) => {
+const writeJson = async (path$1, data, indentOrOptions) => {
 	const { indent, encoding } = parseWriteJsonOptions(indentOrOptions);
 	const content = JSON.stringify(data, null, indent);
 	return writeFile(path$1, content, encoding);

package/dist/global-types.d.ts

@@ -63,6 +63,12 @@ declare global {
         Args extends readonly any[] = any[],
         This = unknown,
     > = Types.FnWithThis<Return, Args, This>;
+    type SyncFn<Return = any, Args extends readonly any[] = any[]> = Types.SyncFn<Return, Args>;
+    type SyncFnWithThis<
+        Return = any,
+        Args extends readonly any[] = any[],
+        This = unknown,
+    > = Types.SyncFnWithThis<Return, Args, This>;
 
     type Entries<BaseType> = Types.Entries<BaseType>;
     type Entry<BaseType> = Types.Entry<BaseType>;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { AsyncFn, Fn } from "./libs/types-4042b7e8.js";
-import { ResultAsync } from "./libs/result-81665e58.js";
+import { AsyncFn, Fn } from "./libs/types-92e74e19.js";
+import { Result } from "./libs/result-4e97f1e0.js";
 
 //#region src/common/error.d.ts
 interface ErrorLike extends Partial<Error> {
@@ -63,14 +63,12 @@ declare const createLock: () => {
 declare const PromiseWithResolvers: <T>() => PromiseWithResolvers<T>;
 //#endregion
 //#region src/common/shell.d.ts
-declare function $(cmd: string): ResultAsync<{
+interface ShellExecResult {
   stdout: string;
   stderr: string;
-}, string>;
-declare function $(cmd: TemplateStringsArray, ...values: any[]): ResultAsync<{
-  stdout: string;
-  stderr: string;
-}, string>;
+}
+declare function $(cmd: string): Promise<Result<ShellExecResult, string>>;
+declare function $(cmd: TemplateStringsArray, ...values: any[]): Promise<Result<ShellExecResult, string>>;
 declare const quoteShellArg: (arg: string) => string;
 //#endregion
 //#region src/common/string.d.ts

package/dist/index.js

@@ -1,5 +1,5 @@
 import "./libs/remeda-662cc9ef.js";
-import { $, PromiseWithResolvers, addPrefix, addSuffix, createLock, createSingleton, debounce, errorToMessage, getErrorMessage, isErrorLike, join, joinWithSlash, linear, normalizeError, parseKeyValuePairs, parseValueToBoolean, quoteShellArg, removePrefix, removeSuffix, scale, sleep, split, splitWithSlash, template, throttle, toForwardSlash, unindent } from "./libs/common-7de47aac.js";
-import "./libs/result-6175a096.js";
+import { $, PromiseWithResolvers, addPrefix, addSuffix, createLock, createSingleton, debounce, errorToMessage, getErrorMessage, isErrorLike, join, joinWithSlash, linear, normalizeError, parseKeyValuePairs, parseValueToBoolean, quoteShellArg, removePrefix, removeSuffix, scale, sleep, split, splitWithSlash, template, throttle, toForwardSlash, unindent } from "./libs/common-ca6da438.js";
+import "./libs/result-1bfb809c.js";
 
 export { $, PromiseWithResolvers, addPrefix, addSuffix, createLock, createSingleton, debounce, errorToMessage, getErrorMessage, isErrorLike, join, joinWithSlash, linear, normalizeError, parseKeyValuePairs, parseValueToBoolean, quoteShellArg, removePrefix, removeSuffix, scale, sleep, split, splitWithSlash, template, throttle, toForwardSlash, unindent };

package/dist/libs/{common-7de47aac.js → common-ca6da438.js}

@@ -1,5 +1,5 @@
 import { l$1 as l, o$5 as o, r$4 as r, t$4 as t$1, t$6 as t, u } from "./remeda-662cc9ef.js";
-import { ResultAsync } from "./result-6175a096.js";
+import { Result } from "./result-1bfb809c.js";
 
 //#region src/common/error.ts
 const isErrorLike = (error) => o(error) && t(error.message);
@@ -199,24 +199,27 @@ const PromiseWithResolvers = () => {
 
 //#endregion
 //#region src/common/shell.ts
-function $(cmd, ...values) {
+const REGEXP_NULL_CHAR = /\x00+/g;
+const REGEXP_SAFE_CHARS = /^[A-Za-z0-9,:=_./-]+$/;
+const REGEXP_SINGLE_QUOTES = /'+/g;
+async function $(cmd, ...values) {
+	const { exec } = await import("node:child_process");
 	const command = t(cmd) ? cmd : cmd.reduce((acc, part, index) => acc + part + (values[index] ?? ""), "");
-	const promise = import("node:child_process").then(({ exec }) => {
-		const { promise: promise$1, reject, resolve } = PromiseWithResolvers();
+	const fn = async () => {
+		const { promise, reject, resolve } = PromiseWithResolvers();
 		exec(command, (error, stdout, stderr) => {
 			if (error) reject(error);
 			else resolve({
-				stdout,
-				stderr
+				stdout: stdout.trim(),
+				stderr: stderr.trim()
 			});
 		});
-		return promise$1;
-	});
-	return ResultAsync.fromPromise(promise, errorToMessage(`Failed to execute command: ${cmd}`));
+		return await promise;
+	};
+	const onThrow = errorToMessage(`Failed to execute command: ${cmd}`);
+	const result = Result.try(fn, onThrow);
+	return result;
 }
-const REGEXP_NULL_CHAR = /\x00+/g;
-const REGEXP_SAFE_CHARS = /^[A-Za-z0-9,:=_./-]+$/;
-const REGEXP_SINGLE_QUOTES = /'+/g;
 const quoteShellArg = (arg) => {
 	if (!arg) return "''";
 	const cleaned = String(arg).replace(REGEXP_NULL_CHAR, "");

package/dist/libs/result-1bfb809c.js

@@ -0,0 +1,179 @@
+import { isPromiseLike, t$4 as t } from "./remeda-662cc9ef.js";
+
+//#region src/result/result.ts
+var Result = class {
+	static ok(value) {
+		return new Ok(value);
+	}
+	static err(error) {
+		return new Err(error);
+	}
+	static try(fnOrData, onThrow) {
+		try {
+			let data = fnOrData;
+			if (t(fnOrData)) data = fnOrData();
+			if (!isPromiseLike(data)) return ok(data);
+			return data.then((value) => ok(value), (error) => err(onThrow ? onThrow(error) : error));
+		} catch (error) {
+			return err(onThrow ? onThrow(error) : error);
+		}
+	}
+	static all(results) {
+		let acc = ok([]);
+		for (const result of results) {
+			if (!result.isOk()) {
+				acc = err(result.error);
+				break;
+			}
+			acc = acc.map((values) => [...values, result.value]);
+		}
+		return acc;
+	}
+	static allSettled(results) {
+		let acc = ok([]);
+		for (const result of results) if (result.isErr() && acc.isErr()) acc = acc.mapErr((errors) => [...errors, result.error]);
+		else if (result.isOk() && acc.isOk()) acc = acc.map((values) => [...values, result.value]);
+		else if (result.isErr() && acc.isOk()) acc = err([result.error]);
+		return acc;
+	}
+	/**
+	* Check if `Result` is `OK`
+	*/
+	isOk() {
+		return this.ok;
+	}
+	/**
+	* Check if `Result` is `OK` and the value matches the predicate
+	*/
+	isOkAnd(predicate) {
+		return this.isOk() && predicate(this.value);
+	}
+	/**
+	* Check if `Result` is `Err`
+	*/
+	isErr() {
+		return !this.ok;
+	}
+	/**
+	* Check if `Result` is `Err` and the error matches the predicate
+	*/
+	isErrAnd(predicate) {
+		return this.isErr() && predicate(this.error);
+	}
+	/**
+	* Maps `Result<T, E>` to `Result<U, E>`
+	*/
+	map(fn) {
+		return this.isErr() ? this : ok(fn(this.value));
+	}
+	/**
+	* Maps `Result<T, E>` to `Result<T, F>`
+	*/
+	mapErr(fn) {
+		return this.isOk() ? this : err(fn(this.error));
+	}
+	and(result) {
+		return this.isErr() ? this : result;
+	}
+	andThen(fn) {
+		return this.isErr() ? this : fn(this.value);
+	}
+	or(result) {
+		return this.isOk() ? this : result;
+	}
+	orElse(fn) {
+		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);
+		} 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);
+		} catch {}
+		return this;
+	}
+	/**
+	* Unwrap the `Ok` value, or return the provided value if `Result` is `Err`
+	*/
+	unwrapOr(defaultValue) {
+		return this.isOk() ? this.value : defaultValue;
+	}
+	/**
+	* 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);
+	}
+	/**
+	* Returns an iterable object that yields the `Ok` value and `Err` value
+	*/
+	iter() {
+		if (this.isOk()) return [
+			true,
+			null,
+			this.value
+		];
+		else return [
+			false,
+			this.error,
+			null
+		];
+	}
+	*[Symbol.iterator]() {
+		if (this.isOk()) return this.value;
+		const self = this;
+		yield self;
+		return self;
+	}
+};
+var Ok = class extends Result {
+	ok = true;
+	_value;
+	constructor(value) {
+		super();
+		this._value = value;
+	}
+	get value() {
+		return this._value;
+	}
+	get error() {
+		return null;
+	}
+};
+var Err = class extends Result {
+	ok = false;
+	_error;
+	constructor(error) {
+		super();
+		this._error = error;
+	}
+	get value() {
+		return null;
+	}
+	get error() {
+		return this._error;
+	}
+};
+const ok = Result.ok;
+const err = Result.err;
+
+//#endregion
+//#region src/result/utils.ts
+function safeTry(body) {
+	const next = body().next();
+	if (isPromiseLike(next)) return next.then((res) => res.value);
+	return next.value;
+}
+
+//#endregion
+export { Err, Ok, Result, err, ok, safeTry };