@terrygonguet/utils 0.11.0 → 0.12.0

package/dist/{async.d.ts → async.d.mts}

@@ -1,25 +1,26 @@
+//#region src/async.d.ts
 declare function pause(ms: number): Promise<void>;
 interface RetryOptions {
-    count?: number;
-    delay?: number | ((retryCount: number, error: any) => number);
+  count?: number;
+  delay?: number | ((retryCount: number, error: any) => number);
 }
 declare function retry(options: RetryOptions): <T>(provider: () => Promise<T>) => Promise<T>;
 declare function retry<T>(provider: () => Promise<T>, options?: RetryOptions): Promise<T>;
 interface AsyncMapOptions<FailFast extends boolean = false, WithSourceIndexes extends boolean = false> {
-    concurrent?: number;
-    failFast?: FailFast;
-    withSourceIndexes?: WithSourceIndexes;
+  concurrent?: number;
+  failFast?: FailFast;
+  withSourceIndexes?: WithSourceIndexes;
 }
 interface AsyncMapResultWithIndexes<U> {
-    results: [i: number, value: U][];
-    errors: [i: number, error: unknown][];
+  results: [i: number, value: U][];
+  errors: [i: number, error: unknown][];
 }
 interface AsyncMapResult<U> {
-    results: U[];
-    errors: unknown[];
+  results: U[];
+  errors: unknown[];
 }
 type AsyncMapFn<T, U> = (el: T, i: number, data: T[]) => Promise<U>;
 declare function asyncMap<T, U, FailFast extends boolean = false, WithSourceIndexes extends boolean = false>(f: AsyncMapFn<T, U>, options?: AsyncMapOptions<FailFast, WithSourceIndexes>): (data: T[]) => Promise<FailFast extends true ? WithSourceIndexes extends true ? [i: number, value: U][] : U[] : WithSourceIndexes extends true ? AsyncMapResultWithIndexes<U> : AsyncMapResult<U>>;
 declare function asyncMap<T, U, FailFast extends boolean = false, WithSourceIndexes extends boolean = false>(data: T[], f: AsyncMapFn<T, U>, options?: AsyncMapOptions<FailFast, WithSourceIndexes>): Promise<FailFast extends true ? WithSourceIndexes extends true ? [i: number, value: U][] : U[] : WithSourceIndexes extends true ? AsyncMapResultWithIndexes<U> : AsyncMapResult<U>>;
-
-export { asyncMap, pause, retry };
+//#endregion
+export { asyncMap, pause, retry };

package/dist/async.mjs

@@ -0,0 +1,82 @@
+//#region src/async.ts
+function pause(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retry(providerOrOptions, options) {
+	if (typeof providerOrOptions == "function") return _retry(providerOrOptions, options);
+	else return (provider) => _retry(provider, providerOrOptions);
+}
+async function _retry(provider, { count = Infinity, delay } = {}) {
+	let retryCount = 0;
+	let lastError;
+	do
+		try {
+			return await provider();
+		} catch (error) {
+			lastError = error;
+			retryCount++;
+			switch (typeof delay) {
+				case "number":
+					await pause(delay);
+					break;
+				case "function":
+					await pause(delay(retryCount, error));
+					break;
+			}
+		}
+	while (retryCount <= count);
+	throw lastError;
+}
+function asyncMap(dataOrF, ForOptions, options) {
+	if (typeof dataOrF == "function" && typeof ForOptions != "function") {
+		const f = dataOrF;
+		const options = ForOptions;
+		return (data) => asyncMap_(data, f, options);
+	} else if (Array.isArray(dataOrF) && typeof ForOptions == "function") return asyncMap_(dataOrF, ForOptions, options);
+	else throw new Error("Invalid arguments passed to asyncMap");
+}
+async function asyncMap_(data, f, { concurrent = 5, failFast = false, withSourceIndexes = false } = {}) {
+	return new Promise((resolve, reject) => {
+		const resolved = [];
+		const errors = [];
+		const inFlight = /* @__PURE__ */ new Map();
+		let next = 0;
+		let stop = false;
+		/** @param {number} i */
+		function queue(i) {
+			if (!stop && i > 0 && inFlight.size == 0) return finish();
+			if (stop || i >= data.length) return;
+			inFlight.set(i, f(data[i], i, data).then((result) => void resolved.push([i, result]), (error) => {
+				if (!failFast) errors.push([i, error]);
+				else {
+					stop = true;
+					reject(error);
+				}
+			}).finally(() => {
+				inFlight.delete(i);
+				queue(next);
+			}));
+			next++;
+		}
+		function finish() {
+			resolved.sort(([a], [b]) => a - b);
+			if (failFast) if (withSourceIndexes) resolve(resolved);
+			else resolve(resolved.map(([, value]) => value));
+			else {
+				errors.sort(([a], [b]) => a - b);
+				if (withSourceIndexes) resolve({
+					results: resolved,
+					errors
+				});
+				else resolve({
+					results: resolved.map(([, value]) => value),
+					errors: errors.map(([, error]) => error)
+				});
+			}
+		}
+		if (data.length == 0) finish();
+		else for (let i = 0; i < concurrent; i++) queue(next);
+	});
+}
+//#endregion
+export { asyncMap, pause, retry };

package/dist/{index.d.ts → index.d.mts}

@@ -1,3 +1,4 @@
+//#region src/index.d.ts
 /**
  * Behaviour is undefined when max < min
  */
@@ -13,5 +14,5 @@ declare function recordListPush<Key extends string, T>(record: Record<Key, T[]>,
 type ExecResult<T, Err = Error> = [null, T] | [Err, null];
 declare function tryCatch<F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<infer T> ? Promise<ExecResult<T>> : ExecResult<ReturnType<F>>;
 declare function tryCatch<Err, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<infer T> ? Promise<ExecResult<T, Err>> : ExecResult<ReturnType<F>, Err>;
-
-export { type ExecResult, clamp, createNoopProxy, exhaustive, hash, mapListPush, noop, range, recordListPush, tryCatch, yesno };
+//#endregion
+export { ExecResult, clamp, createNoopProxy, exhaustive, hash, mapListPush, noop, range, recordListPush, tryCatch, yesno };

package/dist/index.mjs

@@ -0,0 +1,66 @@
+//#region src/index.ts
+/**
+* Behaviour is undefined when max < min
+*/
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function createNoopProxy() {
+	const noop = () => proxy;
+	const no = () => false;
+	const yes = () => true;
+	const proxy = new Proxy(() => {}, {
+		get: noop,
+		set: noop,
+		apply: noop,
+		construct: noop,
+		deleteProperty: yes,
+		has: yes,
+		preventExtensions: no,
+		defineProperty: no
+	});
+	return proxy;
+}
+function noop() {}
+function exhaustive(_) {
+	throw new Error("This should never be called");
+}
+async function hash(message) {
+	const data = new TextEncoder().encode(message);
+	return await crypto.subtle.digest("SHA-1", data);
+}
+function* range(start, end, step = 1) {
+	for (let i = start; i < end; i += step) yield i;
+}
+function yesno(value) {
+	switch (value?.toLowerCase()) {
+		case "1":
+		case "y":
+		case "yes":
+		case "true":
+		case "on": return true;
+		default: return false;
+	}
+}
+function mapListPush(map, key, value) {
+	const arr = map.get(key) ?? [];
+	arr.push(value);
+	return map.set(key, arr);
+}
+function recordListPush(record, key, value) {
+	const arr = record[key] ?? [];
+	arr.push(value);
+	record[key] = arr;
+	return record;
+}
+function tryCatch(f, ...args) {
+	try {
+		const promiseOrResult = f(...args);
+		if (promiseOrResult instanceof Promise) return promiseOrResult.then((result) => [null, result], (error) => [error, null]);
+		else return [null, promiseOrResult];
+	} catch (error) {
+		return [error, null];
+	}
+}
+//#endregion
+export { clamp, createNoopProxy, exhaustive, hash, mapListPush, noop, range, recordListPush, tryCatch, yesno };

package/dist/{json.d.ts → json.d.mts}

@@ -1,28 +1,21 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/json.d.ts
 /**
  * This function does no runtime type checking,
  * make sure that the parsed value is valid
  */
 declare function safeParse<T>(str: string, defaultValue: T, reviver?: (key: string, value: any) => any): T;
-type SchemaParseReturn<Schema extends StandardSchemaV1> = [parseError: Error, validationFailure: null, output: null] | [
-    parseError: null,
-    validationFailure: StandardSchemaV1.FailureResult,
-    output: null
-] | [
-    parseError: null,
-    validationFailure: null,
-    output: StandardSchemaV1.InferOutput<Schema>
-];
+type SchemaParseReturn<Schema extends StandardSchemaV1> = [parseError: Error, validationFailure: null, output: null] | [parseError: null, validationFailure: StandardSchemaV1.FailureResult, output: null] | [parseError: null, validationFailure: null, output: StandardSchemaV1.InferOutput<Schema>];
 declare function schemaParse<Schema extends StandardSchemaV1, Async extends boolean = false>(schema: Schema, str: string, options?: {
-    reviver?(key: string, value: any): any;
-    async?: Async;
+  reviver?(key: string, value: any): any;
+  async?: Async;
 }): Async extends true ? Promise<SchemaParseReturn<Schema>> : SchemaParseReturn<Schema>;
 declare function schemaParseWithDefault<Schema extends StandardSchemaV1, Async extends boolean = false>(schema: Schema, str: string, defaultValue: StandardSchemaV1.InferOutput<Schema>, options?: {
-    reviver?(key: string, value: any): any;
-    async?: Async;
-    out_parseError?: Error[];
-    out_validationFailure?: StandardSchemaV1.FailureResult[];
+  reviver?(key: string, value: any): any;
+  async?: Async;
+  out_parseError?: Error[];
+  out_validationFailure?: StandardSchemaV1.FailureResult[];
 }): Async extends true ? Promise<StandardSchemaV1.InferOutput<Schema>> : StandardSchemaV1.InferOutput<Schema>;
-
-export { safeParse, schemaParse, schemaParseWithDefault };
+//#endregion
+export { safeParse, schemaParse, schemaParseWithDefault };

package/dist/json.mjs

@@ -0,0 +1,87 @@
+//#region src/json.ts
+/**
+* This function does no runtime type checking,
+* make sure that the parsed value is valid
+*/
+function safeParse(str, defaultValue, reviver) {
+	try {
+		return JSON.parse(str, reviver);
+	} catch (_) {
+		return defaultValue;
+	}
+}
+/**
+* ! HACK relax type constraints because TS has trouble with options.async for some reason
+*/
+function schemaParse(schema, str, options) {
+	try {
+		const parsed = JSON.parse(str, options?.reviver);
+		const result = schema["~standard"].validate(parsed);
+		if (options?.async) if (result instanceof Promise) return result.then((result) => result.issues ? [
+			null,
+			result,
+			null
+		] : [
+			null,
+			null,
+			result.value
+		], (err) => [
+			err,
+			null,
+			null
+		]);
+		else return Promise.resolve(result.issues ? [
+			null,
+			result,
+			null
+		] : [
+			null,
+			null,
+			result.value
+		]);
+		else if (result instanceof Promise) throw new Error("Function schemaParse() whas called with an async schema but without the async flag");
+		else if (result.issues) return [
+			null,
+			result,
+			null
+		];
+		else return [
+			null,
+			null,
+			result.value
+		];
+	} catch (error) {
+		return [
+			error,
+			null,
+			null
+		];
+	}
+}
+/**
+* ! HACK relax type constraints because TS has trouble with options.async for some reason
+*/
+function schemaParseWithDefault(schema, str, defaultValue, options) {
+	const result = schemaParse(schema, str, options);
+	if (result instanceof Promise) return result.then(([error, failure, value]) => {
+		if (failure) {
+			options?.out_validationFailure?.push(failure);
+			return defaultValue;
+		} else if (error) {
+			options?.out_parseError?.push(error);
+			return defaultValue;
+		} else return value;
+	});
+	else {
+		const [error, failure, value] = result;
+		if (failure) {
+			options?.out_validationFailure?.push(failure);
+			return defaultValue;
+		} else if (error) {
+			options?.out_parseError?.push(error);
+			return defaultValue;
+		} else return value;
+	}
+}
+//#endregion
+export { safeParse, schemaParse, schemaParseWithDefault };

package/dist/option.d.mts

@@ -0,0 +1,52 @@
+//#region src/option.d.ts
+declare class Option<T> {
+  #private;
+  readonly _kind: "Some" | "None";
+  readonly value: T;
+  private constructor();
+  [Symbol.iterator](): Iterator<Option<T>, T>;
+  static do<T>(f: () => Iterator<Option<any>, T, any>): Option<T>;
+  static from<T>(maybeValue: unknown, {
+    allowOptionLikePOJO
+  }?: {
+    allowOptionLikePOJO?: boolean | undefined;
+  }): Option<T>;
+  static wrapFunction<T, Args extends any[]>(f: (...args: Args) => T | undefined | null, {
+    allowOptionLikePOJO
+  }?: {
+    allowOptionLikePOJO?: boolean | undefined;
+  }): (...args: Args) => Option<T>;
+  static isOption<T>(maybeOption: unknown): maybeOption is Option<T>;
+  static Some<T>(value: T): Option<T>;
+  static None<T>(): Option<T>;
+  [Symbol.toPrimitive](): string;
+  isSome(): boolean;
+  isNone(): boolean;
+  equals(other: Option<T>): boolean;
+  map<U>(f: (value: T) => U, {
+    coalesce
+  }?: {
+    coalesce?: boolean | undefined;
+  }): Option<U>;
+  flatMap<U>(f: (value: T) => Option<U>): Option<U>;
+  flatten(): T extends Option<infer U> ? Option<U> : Option<T>;
+  orDefault(defaultValue: T): T;
+  orNull(): T | null;
+  orUndefined(): T | undefined;
+  or<U>(other: Option<U>): Option<T> | Option<U>;
+  unwrap(): T;
+  filter<U extends T>(predicate: (value: T) => value is U): Option<U>;
+  filter(predicate: (value: T) => boolean): Option<T>;
+  toString(): string;
+}
+declare function arrayGet<T>(arr: T[], i: number): Option<T>;
+declare function arrayFind<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<T>;
+declare function arrayFindLast<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<T>;
+declare function arrayFindIndex<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<number>;
+declare function arrayFindLastIndex<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<number>;
+declare function arrayIndexOf<T>(arr: T[], item: T, fromIndex?: number): Option<number>;
+declare function arrayLastIndexOf<T>(arr: T[], item: T, fromIndex?: number): Option<number>;
+declare function arrPop<T>(arr: T[]): Option<T>;
+declare function arrShift<T>(arr: T[]): Option<T>;
+//#endregion
+export { Option, arrPop, arrShift, arrayFind, arrayFindIndex, arrayFindLast, arrayFindLastIndex, arrayGet, arrayIndexOf, arrayLastIndexOf };

package/dist/option.mjs

@@ -0,0 +1,142 @@
+//#region src/option.ts
+var Option = class Option {
+	_kind;
+	value;
+	constructor(_kind, value = void 0) {
+		this._kind = _kind;
+		this.value = value;
+	}
+	*[Symbol.iterator]() {
+		yield this;
+		if (this.isNone()) throw new Error("Tried to unwrap a None() via its iterator");
+		else return this.value;
+	}
+	static do(f) {
+		const gen = f();
+		let iter = gen.next();
+		while (!iter.done) switch (iter.value._kind) {
+			case "Some":
+				iter = gen.next(iter.value.value);
+				break;
+			case "None":
+				gen.return?.(void 0);
+				return Option.None();
+		}
+		return Option.Some(iter.value);
+	}
+	static from(maybeValue, { allowOptionLikePOJO = false } = {}) {
+		if (maybeValue === void 0 || maybeValue === null) return Option.None();
+		else if (Option.isOption(maybeValue)) return maybeValue;
+		else if (allowOptionLikePOJO && maybeValue && typeof maybeValue == "object" && "_kind" in maybeValue && (maybeValue._kind == "Some" || maybeValue._kind == "None")) return new Option(maybeValue._kind, maybeValue.value);
+		else return Option.Some(maybeValue);
+	}
+	static wrapFunction(f, { allowOptionLikePOJO = false } = {}) {
+		return (...args) => Option.from(f(...args), { allowOptionLikePOJO });
+	}
+	static isOption(maybeOption) {
+		return maybeOption instanceof Option;
+	}
+	static Some(value) {
+		return new Option("Some", value);
+	}
+	static #None = new Option("None");
+	static None() {
+		return this.#None;
+	}
+	[Symbol.toPrimitive]() {
+		return this.toString();
+	}
+	isSome() {
+		return this._kind == "Some";
+	}
+	isNone() {
+		return this._kind == "None";
+	}
+	equals(other) {
+		if (this.isNone()) return other.isNone();
+		else if (other.isNone()) return false;
+		else return this.value == other.value;
+	}
+	map(f, { coalesce = false } = {}) {
+		if (this.isNone()) return Option.None();
+		else if (coalesce) return Option.from(f(this.value));
+		else return Option.Some(f(this.value));
+	}
+	flatMap(f) {
+		if (this.isNone()) return Option.None();
+		else return f(this.value);
+	}
+	flatten() {
+		if (this.isNone()) return Option.None();
+		else return Option.isOption(this.value) ? this.value : this;
+	}
+	orDefault(defaultValue) {
+		if (this.isNone()) return defaultValue;
+		else return this.value;
+	}
+	orNull() {
+		if (this.isNone()) return null;
+		else return this.value;
+	}
+	orUndefined() {
+		if (this.isNone()) return void 0;
+		else return this.value;
+	}
+	or(other) {
+		if (this.isNone()) return other;
+		else return this;
+	}
+	unwrap() {
+		if (this.isNone()) throw new Error("Tried to unwrap a None()");
+		else return this.value;
+	}
+	filter(predicate) {
+		if (this.isNone()) return this;
+		else return predicate(this.value) ? this : Option.None();
+	}
+	toString() {
+		if (this.isNone()) return "None()";
+		switch (typeof this.value) {
+			case "string": return `Some("${this.value}")`;
+			case "function":
+			case "object": return `Some(${JSON.stringify(this.value)})`;
+			default: return `Some(${this.value})`;
+		}
+	}
+};
+function arrayGet(arr, i) {
+	if (i >= arr.length || i < 0) return Option.None();
+	else return Option.Some(arr[i]);
+}
+function arrayFind(arr, predicate, thisArg) {
+	return Option.from(arr.find(predicate, thisArg));
+}
+function arrayFindLast(arr, predicate, thisArg) {
+	return Option.from(arr.findLast(predicate, thisArg));
+}
+function arrayFindIndex(arr, predicate, thisArg) {
+	const idx = arr.findIndex(predicate, thisArg);
+	return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrayFindLastIndex(arr, predicate, thisArg) {
+	const idx = arr.findLastIndex(predicate, thisArg);
+	return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrayIndexOf(arr, item, fromIndex) {
+	const idx = arr.indexOf(item, fromIndex);
+	return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrayLastIndexOf(arr, item, fromIndex) {
+	const idx = arr.lastIndexOf(item, fromIndex);
+	return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrPop(arr) {
+	if (arr.length == 0) return Option.None();
+	else return Option.Some(arr.pop());
+}
+function arrShift(arr) {
+	if (arr.length == 0) return Option.None();
+	else return Option.Some(arr.shift());
+}
+//#endregion
+export { Option, arrPop, arrShift, arrayFind, arrayFindIndex, arrayFindLast, arrayFindLastIndex, arrayGet, arrayIndexOf, arrayLastIndexOf };

package/dist/{random.d.ts → random.d.mts}

@@ -1,3 +1,4 @@
+//#region src/random.d.ts
 /**
  * Generates a random integer between `0` (inclusive) and `max` (exlusive)
  */
@@ -19,5 +20,5 @@ declare function make_randi(prng: typeof Math.random): typeof randi;
 declare function make_randf(prng: typeof Math.random): (minOrMax: number, max?: number) => number;
 declare function make_shuffle(prng: typeof Math.random): <T>(arr: T[]) => T[];
 declare function seeded(seed: string | number): typeof Math.random;
-
-export { make_randf, make_randi, make_shuffle, randf, randi, seeded, shuffle };
+//#endregion
+export { make_randf, make_randi, make_shuffle, randf, randi, seeded, shuffle };

package/dist/random.mjs

@@ -0,0 +1,79 @@
+//#region src/random.ts
+const base_randi = make_randi(Math.random);
+function randi(minOrMax, max) {
+	if (typeof max == "number") return base_randi(minOrMax, max);
+	else return base_randi(minOrMax);
+}
+const base_randf = make_randf(Math.random);
+function randf(minOrMax, max) {
+	if (typeof max == "number") return base_randf(minOrMax, max);
+	else return base_randf(minOrMax);
+}
+const shuffle = make_shuffle(Math.random);
+function make_randi(prng) {
+	return function randi(minOrMax, max) {
+		if (typeof max == "number") {
+			const min = minOrMax;
+			const delta = max - min;
+			return min + Math.floor(prng() * delta);
+		} else return Math.floor(prng() * minOrMax);
+	};
+}
+function make_randf(prng) {
+	return function randf(minOrMax, max) {
+		if (typeof max == "number") {
+			const min = minOrMax;
+			const delta = max - min;
+			return min + prng() * delta;
+		} else return prng() * minOrMax;
+	};
+}
+function make_shuffle(prng) {
+	const randi = make_randi(prng);
+	return function shuffle(arr) {
+		const clone = Array.from(arr);
+		for (let i = 0; i < clone.length - 2; i++) {
+			const j = randi(i, clone.length);
+			const temp = clone[i];
+			clone[i] = clone[j];
+			clone[j] = temp;
+		}
+		return clone;
+	};
+}
+function seeded(seed) {
+	if (typeof seed == "string") seed = cyrb128(seed);
+	else seed ^= 3735928559;
+	const prng = splitmix32(seed);
+	for (let i = 0; i < 15; i++) prng();
+	return prng;
+}
+function cyrb128(str) {
+	let h1 = 1779033703, h2 = 3144134277, h3 = 1013904242, h4 = 2773480762;
+	for (let i = 0, k; i < str.length; i++) {
+		k = str.charCodeAt(i);
+		h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+		h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+		h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+		h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+	}
+	h1 = Math.imul(h3 ^ h1 >>> 18, 597399067);
+	h2 = Math.imul(h4 ^ h2 >>> 22, 2869860233);
+	h3 = Math.imul(h1 ^ h3 >>> 17, 951274213);
+	h4 = Math.imul(h2 ^ h4 >>> 19, 2716044179);
+	h1 ^= h2 ^ h3 ^ h4;
+	return h1 >>> 0;
+}
+function splitmix32(a) {
+	return function() {
+		a |= 0;
+		a = a + 2654435769 | 0;
+		let t = a ^ a >>> 16;
+		t = Math.imul(t, 569420461);
+		t = t ^ t >>> 15;
+		t = Math.imul(t, 1935289751);
+		return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
+	};
+}
+//#endregion
+export { make_randf, make_randi, make_shuffle, randf, randi, seeded, shuffle };

package/dist/result.d.mts

@@ -0,0 +1,57 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/result.d.ts
+declare class Result<Err extends Error, T> {
+  value: T | null;
+  error: Err | null;
+  constructor(value: null, error: Err);
+  constructor(value: T, error: null);
+  asTuple(): [Err, null] | [null, T];
+  asObject(): {
+    value: null;
+    error: Err;
+  } | {
+    value: T;
+    error: null;
+  };
+  andThen<Err2 extends Error, F extends (value: T) => any>(f: F): ReturnType<F> extends Promise<infer U> ? AsyncResult<Err | Err2, U> : Result<Err | Err2, ReturnType<F>>;
+  match(onValue: (value: T) => void): void;
+  match<U>(onValue: (value: T) => U, onError: (error: Err) => U): U;
+  recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): ReturnType<F> extends Promise<T> ? AsyncResult<Err2, T> : Result<Err2, T>;
+  unwrap(): T;
+  unwrapErr(): Err;
+}
+declare class AsyncResult<Err extends Error, T> {
+  promise: Promise<T>;
+  constructor(promise: Promise<T>);
+  asTuple(): Promise<[Err, null] | [null, T]>;
+  asObject(): Promise<{
+    value: null;
+    error: Err;
+  } | {
+    value: T;
+    error: null;
+  }>;
+  then<U>(cb: (value: Result<Err, T>) => U | Promise<U>): Promise<U>;
+  andThen<Err2 extends Error, F extends (value: T) => any>(f: F): AsyncResult<Err | Err2, Awaited<ReturnType<F>>>;
+  match(onValue: (value: T) => void): Promise<void>;
+  match<U>(onValue: (value: T) => U, onError: (error: Err) => U): Promise<U>;
+  recover<Err2 extends Error, F extends (error: Err) => T | Promise<T>>(f: F): AsyncResult<Err2, T>;
+  unwrap(): Promise<T>;
+  unwrapErr(): Promise<Err>;
+}
+declare function safe<Err extends Error, T>(promise: Promise<T>): AsyncResult<Error, T>;
+declare function safe<Err extends Error, F extends (...args: any) => Promise<any>>(f: F, ...args: Parameters<F>): AsyncResult<Err, Awaited<ReturnType<F>>>;
+declare function safe<Err extends Error, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): Result<Err, ReturnType<F>>;
+declare class SafeFunctionValidationError extends Error {
+  name: string;
+  issues: StandardSchemaV1.FailureResult["issues"];
+  constructor(message: string, issues: StandardSchemaV1.FailureResult["issues"], options?: ErrorOptions);
+}
+interface MakeSafeFnOptions<ParamsSchema extends StandardSchemaV1 | undefined, ReturnSchema extends StandardSchemaV1 | undefined> {
+  paramsSchema?: ParamsSchema;
+  returnSchema?: ReturnSchema;
+}
+declare function makeSafeFn<Err extends Error, ParamsSchema extends StandardSchemaV1 | undefined, ReturnSchema extends StandardSchemaV1 | undefined, F extends (...args: ParamsSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ParamsSchema> : any) => ReturnSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<ReturnSchema> : any>(f: F, options?: MakeSafeFnOptions<ParamsSchema, ReturnSchema>): (...args: Parameters<F>) => Result<Err, ReturnType<F>>;
+//#endregion
+export { AsyncResult, Result, SafeFunctionValidationError, makeSafeFn, safe };