@duplojs/lang 0.0.1-beta.1 → 0.0.1-beta.10

package/dist/either/right/group.mjs

@@ -1,8 +1,8 @@
 import { entries } from "../../object/entries.mjs";
 import { isLeft } from "../left/is.mjs";
+import { reduce, reduceFrom } from "../../array/reduce.mjs";
 import { success } from "./success.mjs";
 import { whenIsRight } from "./when.mjs";
-import { reduce, reduceFrom } from "../../array/reduce.mjs";
 import { isType } from "../../common/isType.mjs";
 import { pipe } from "../../common/pipe.mjs";
 import { when } from "../../common/when.mjs";

package/dist/either/right/index.d.ts

@@ -1,13 +1,14 @@
+export * from './asyncGroup';
 export * from './asyncPipe';
 export * from './create';
+export * from './group';
 export * from './is';
 export * from './ok';
 export * from './pipe';
+export * from './result';
+export * from './some';
 export * from './success';
+export * from './unwrap';
+export * from './unwrapOrThrow';
 export * from './when';
 export * from './whenOtherwise';
-export * from './result';
-export * from './unwrapOrThrow';
-export * from './unwrap';
-export * from './group';
-export * from './asyncGroup';

package/dist/either/right/some.cjs

@@ -0,0 +1,15 @@
+const require_kind = require("../kind.cjs");
+const require_create = require("./create.cjs");
+//#region scripts/either/right/some.ts
+const someKind = require_kind.createKind("some");
+function some(value) {
+	return {
+		[require_create.rightKind.runTimeKey]: null,
+		[require_kind.informationKind.runTimeKey]: "some",
+		[require_kind.valueKind.runTimeKey]: value,
+		[someKind.runTimeKey]: null
+	};
+}
+//#endregion
+exports.some = some;
+exports.someKind = someKind;

package/dist/either/right/some.d.ts

@@ -0,0 +1,7 @@
+import { Right } from './create';
+import type * as DKind from '../../kind';
+import type * as DCommon from '../../common';
+export declare const someKind: DKind.Handler<DKind.Definition<"@DuplojsLangEither/some", unknown>>;
+export interface Some<GenericValue extends unknown> extends DCommon.Forward<DKind.Kind<typeof someKind> & Right<"some", GenericValue>> {
+}
+export declare function some<GenericValue extends unknown>(value: GenericValue): Some<GenericValue>;

package/dist/either/right/some.mjs

@@ -0,0 +1,14 @@
+import { createKind, informationKind, valueKind } from "../kind.mjs";
+import { rightKind } from "./create.mjs";
+//#region scripts/either/right/some.ts
+const someKind = createKind("some");
+function some(value) {
+	return {
+		[rightKind.runTimeKey]: null,
+		[informationKind.runTimeKey]: "some",
+		[valueKind.runTimeKey]: value,
+		[someKind.runTimeKey]: null
+	};
+}
+//#endregion
+export { some, someKind };

package/dist/either/toMaybe.cjs

@@ -0,0 +1,12 @@
+const require_is = require("./left/is.cjs");
+const require_none = require("./left/none.cjs");
+const require_is$1 = require("./right/is.cjs");
+const require_some = require("./right/some.cjs");
+//#region scripts/either/toMaybe.ts
+function toMaybe(input) {
+	if (require_is$1.isRight(input) || require_is.isLeft(input)) return input;
+	if (input === null || input === void 0) return require_none.none();
+	return require_some.some(input);
+}
+//#endregion
+exports.toMaybe = toMaybe;

package/dist/either/toMaybe.d.ts

@@ -0,0 +1,5 @@
+import { Left, None } from './left';
+import { Some, Right } from './right';
+type Either = Right | Left;
+export declare function toMaybe<GenericInput extends unknown>(input: GenericInput): (GenericInput extends Either ? GenericInput : GenericInput extends null | undefined ? None : Some<GenericInput>);
+export {};

package/dist/either/toMaybe.mjs

@@ -0,0 +1,12 @@
+import { isLeft } from "./left/is.mjs";
+import { none } from "./left/none.mjs";
+import { isRight } from "./right/is.mjs";
+import { some } from "./right/some.mjs";
+//#region scripts/either/toMaybe.ts
+function toMaybe(input) {
+	if (isRight(input) || isLeft(input)) return input;
+	if (input === null || input === void 0) return none();
+	return some(input);
+}
+//#endregion
+export { toMaybe };

package/dist/either/types/mayBe.d.ts

@@ -0,0 +1,3 @@
+import { None } from '../left';
+import { Some } from '../right';
+export type MayBe<GenericValue extends unknown> = (Some<GenericValue> | None);

package/dist/either/unwrapOr.cjs

@@ -0,0 +1,14 @@
+const require_kind = require("./kind.cjs");
+const require_is = require("./right/is.cjs");
+//#region scripts/either/unwrapOr.ts
+function unwrapOr(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOr(input, value);
+	}
+	const [input, value] = args;
+	if (require_is.isRight(input)) return require_kind.valueKind.getValue(input);
+	return value;
+}
+//#endregion
+exports.unwrapOr = unwrapOr;

package/dist/either/unwrapOr.d.ts

@@ -0,0 +1,8 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetValue } from './types';
+import type * as DCommon from '../common';
+type Either = Right | Left;
+export declare function unwrapOr<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(input: GenericInput, value: GenericValue): (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export declare function unwrapOr<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(value: GenericValue): (input: GenericInput) => (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export {};

package/dist/either/unwrapOr.mjs

@@ -0,0 +1,14 @@
+import { valueKind } from "./kind.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/unwrapOr.ts
+function unwrapOr(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOr(input, value);
+	}
+	const [input, value] = args;
+	if (isRight(input)) return valueKind.getValue(input);
+	return value;
+}
+//#endregion
+export { unwrapOr };

package/dist/either/unwrapOtherwise.cjs

@@ -0,0 +1,14 @@
+const require_kind = require("./kind.cjs");
+const require_is = require("./right/is.cjs");
+//#region scripts/either/unwrapOtherwise.ts
+function unwrapOtherwise(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOtherwise(input, value);
+	}
+	const [input, value] = args;
+	if (require_is.isRight(input)) return require_kind.valueKind.getValue(input);
+	return value();
+}
+//#endregion
+exports.unwrapOtherwise = unwrapOtherwise;

package/dist/either/unwrapOtherwise.d.ts

@@ -0,0 +1,8 @@
+import { Left } from './left';
+import { Right } from './right';
+import { GetValue } from './types';
+import type * as DCommon from '../common';
+type Either = Right | Left;
+export declare function unwrapOtherwise<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(input: GenericInput, value: () => GenericValue): (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export declare function unwrapOtherwise<GenericInput extends Either | DCommon.AnyValue, const GenericValue extends unknown>(value: () => GenericValue): (input: GenericInput) => (GetValue<Extract<GenericInput, Right>> | GenericValue);
+export {};

package/dist/either/unwrapOtherwise.mjs

@@ -0,0 +1,14 @@
+import { valueKind } from "./kind.mjs";
+import { isRight } from "./right/is.mjs";
+//#region scripts/either/unwrapOtherwise.ts
+function unwrapOtherwise(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (input) => unwrapOtherwise(input, value);
+	}
+	const [input, value] = args;
+	if (isRight(input)) return valueKind.getValue(input);
+	return value();
+}
+//#endregion
+export { unwrapOtherwise };

package/dist/generator/asyncChunk.d.ts

@@ -1,2 +1,3 @@
-export declare function asyncChunk<const GenericItem extends unknown>(size: number): (iterator: AsyncIterable<GenericItem>) => AsyncGenerator<GenericItem[], unknown, unknown>;
-export declare function asyncChunk<const GenericItem extends unknown>(iterator: AsyncIterable<GenericItem>, size: number): AsyncGenerator<GenericItem[], unknown, unknown>;
+import type * as DArray from '../array';
+export declare function asyncChunk<const GenericItem extends unknown, GenericSize extends number>(size: GenericSize): (iterator: AsyncIterable<GenericItem>) => AsyncGenerator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;
+export declare function asyncChunk<const GenericItem extends unknown, GenericSize extends number>(iterator: AsyncIterable<GenericItem>, size: GenericSize): AsyncGenerator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;

package/dist/generator/chunk.d.ts

@@ -1,2 +1,3 @@
-export declare function chunk<const GenericItem extends unknown>(size: number): (iterator: Iterable<GenericItem>) => Generator<GenericItem[], unknown, unknown>;
-export declare function chunk<const GenericItem extends unknown>(iterator: Iterable<GenericItem>, size: number): Generator<GenericItem[], unknown, unknown>;
+import type * as DArray from '../array';
+export declare function chunk<const GenericItem extends unknown, GenericSize extends number>(size: GenericSize): (iterator: Iterable<GenericItem>) => Generator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;
+export declare function chunk<const GenericItem extends unknown, GenericSize extends number>(iterator: Iterable<GenericItem>, size: GenericSize): Generator<readonly GenericItem[] & DArray.MinElements<1> & (number extends GenericSize ? unknown : DArray.MaxElements<GenericSize>), unknown, unknown>;

package/dist/generator/reduce.cjs

@@ -1,6 +1,7 @@
+const require_kind = require("./kind.cjs");
 const require_reduce = require("../array/reduce.cjs");
 //#region scripts/generator/reduce.ts
-const reduceKind = require("./kind.cjs").createKind("reduce");
+const reduceKind = require_kind.createKind("reduce");
 function reduceFrom(value) {
 	return { [reduceKind.runTimeKey]: value };
 }

package/dist/generator/reduce.mjs

@@ -1,5 +1,5 @@
-import { reduceTools } from "../array/reduce.mjs";
 import { createKind } from "./kind.mjs";
+import { reduceTools } from "../array/reduce.mjs";
 //#region scripts/generator/reduce.ts
 const reduceKind = createKind("reduce");
 function reduceFrom(value) {

package/dist/generator/types/flat.d.ts

@@ -1,3 +1,3 @@
 import type * as DCommon from '../../common';
-export type FlatIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
-export type FlatAsyncIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue extends AsyncIterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
+export type FlatIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends string ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;
+export type FlatAsyncIterator<GenericValue extends unknown, GenericDepth extends number, GenericAcc extends never[] = []> = DCommon.IsEqual<GenericAcc["length"], GenericDepth> extends true ? GenericValue : DCommon.IsEqual<GenericAcc["length"], 250> extends true ? GenericValue : GenericValue extends string ? GenericValue : GenericValue extends Iterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue extends AsyncIterable<infer InferredValue> ? FlatIterator<InferredValue, GenericDepth, [...GenericAcc, never]> : GenericValue;

package/dist/index.cjs

@@ -15,16 +15,18 @@ const require_callThen = require("./common/callThen.cjs");
 const require_index$1 = require("./object/index.cjs");
 const require_clone = require("./common/clone.cjs");
 const require_index$2 = require("./common/constraint/cast/index.cjs");
+const require_index$3 = require("./common/constraint/infer/index.cjs");
+const require_remove = require("./common/constraint/remove.cjs");
 const require_detachObjectMethod = require("./common/detachObjectMethod.cjs");
 const require_enum = require("./common/enum.cjs");
 const require_equal = require("./common/equal.cjs");
 const require_escapeRegExp = require("./common/escapeRegExp.cjs");
 const require_externalPromise = require("./common/externalPromise.cjs");
 const require_falsy = require("./common/falsy.cjs");
-const require_index$3 = require("./array/index.cjs");
-const require_index$4 = require("./generator/index.cjs");
-const require_index$5 = require("./either/index.cjs");
-const require_index$6 = require("./chrono/index.cjs");
+const require_index$4 = require("./array/index.cjs");
+const require_index$5 = require("./generator/index.cjs");
+const require_index$6 = require("./either/index.cjs");
+const require_index$7 = require("./chrono/index.cjs");
 const require_formData = require("./common/formData.cjs");
 const require_forward = require("./common/forward.cjs");
 const require_forwardAsserts = require("./common/forwardAsserts.cjs");
@@ -49,7 +51,7 @@ const require_promiseAll = require("./common/promiseAll.cjs");
 const require_promiseObject = require("./common/promiseObject.cjs");
 const require_queue = require("./common/queue.cjs");
 const require_simpleClone = require("./common/simpleClone.cjs");
-const require_index$7 = require("./string/index.cjs");
+const require_index$8 = require("./string/index.cjs");
 const require_stringToBytes = require("./common/stringToBytes.cjs");
 const require_stringToMillisecond = require("./common/stringToMillisecond.cjs");
 const require_toCurriedPredicate = require("./common/toCurriedPredicate.cjs");
@@ -59,68 +61,68 @@ const require_truthy = require("./common/truthy.cjs");
 const require_when = require("./common/when.cjs");
 const require_whenElse = require("./common/whenElse.cjs");
 const require_whenNot = require("./common/whenNot.cjs");
-const require_index$8 = require("./common/index.cjs");
-const require_index$9 = require("./number/index.cjs");
-const require_index$10 = require("./dataStructure/index.cjs");
-const require_index$11 = require("./tuple/index.cjs");
-const require_index$12 = require("./modeling/index.cjs");
-const require_index$13 = require("./pattern/index.cjs");
-const require_index$14 = require("./invocation/index.cjs");
-const require_index$15 = require("./path/index.cjs");
-const require_index$16 = require("./printer/index.cjs");
+const require_index$9 = require("./common/index.cjs");
+const require_index$10 = require("./path/index.cjs");
+const require_index$11 = require("./number/index.cjs");
+const require_index$12 = require("./dataStructure/index.cjs");
+const require_index$13 = require("./tuple/index.cjs");
+const require_index$14 = require("./modeling/index.cjs");
+const require_index$15 = require("./pattern/index.cjs");
+const require_index$16 = require("./invocation/index.cjs");
+const require_index$17 = require("./printer/index.cjs");
 Object.defineProperty(exports, "A", {
 	enumerable: true,
 	get: function() {
-		return require_index$3.array_exports;
+		return require_index$4.array_exports;
 	}
 });
 exports.AssertsError = require_asserts.AssertsError;
 Object.defineProperty(exports, "C", {
 	enumerable: true,
 	get: function() {
-		return require_index$6.chrono_exports;
+		return require_index$7.chrono_exports;
 	}
 });
 Object.defineProperty(exports, "DArray", {
 	enumerable: true,
 	get: function() {
-		return require_index$3.array_exports;
+		return require_index$4.array_exports;
 	}
 });
 Object.defineProperty(exports, "DChrono", {
 	enumerable: true,
 	get: function() {
-		return require_index$6.chrono_exports;
+		return require_index$7.chrono_exports;
 	}
 });
 Object.defineProperty(exports, "DCommon", {
 	enumerable: true,
 	get: function() {
-		return require_index$8.common_exports;
+		return require_index$9.common_exports;
 	}
 });
 Object.defineProperty(exports, "DDataStructure", {
 	enumerable: true,
 	get: function() {
-		return require_index$10.dataStructure_exports;
+		return require_index$12.dataStructure_exports;
 	}
 });
 Object.defineProperty(exports, "DEither", {
 	enumerable: true,
 	get: function() {
-		return require_index$5.either_exports;
+		return require_index$6.either_exports;
 	}
 });
 Object.defineProperty(exports, "DGenerator", {
 	enumerable: true,
 	get: function() {
-		return require_index$4.generator_exports;
+		return require_index$5.generator_exports;
 	}
 });
 Object.defineProperty(exports, "DInvocation", {
 	enumerable: true,
 	get: function() {
-		return require_index$14.invocation_exports;
+		return require_index$16.invocation_exports;
 	}
 });
 Object.defineProperty(exports, "DKind", {
@@ -132,13 +134,13 @@ Object.defineProperty(exports, "DKind", {
 Object.defineProperty(exports, "DModeling", {
 	enumerable: true,
 	get: function() {
-		return require_index$12.modeling_exports;
+		return require_index$14.modeling_exports;
 	}
 });
 Object.defineProperty(exports, "DNumber", {
 	enumerable: true,
 	get: function() {
-		return require_index$9.number_exports;
+		return require_index$11.number_exports;
 	}
 });
 Object.defineProperty(exports, "DObject", {
@@ -150,55 +152,55 @@ Object.defineProperty(exports, "DObject", {
 Object.defineProperty(exports, "DPath", {
 	enumerable: true,
 	get: function() {
-		return require_index$15.path_exports;
+		return require_index$10.path_exports;
 	}
 });
 Object.defineProperty(exports, "DPattern", {
 	enumerable: true,
 	get: function() {
-		return require_index$13.pattern_exports;
+		return require_index$15.pattern_exports;
 	}
 });
 Object.defineProperty(exports, "DPrinter", {
 	enumerable: true,
 	get: function() {
-		return require_index$16.printer_exports;
+		return require_index$17.printer_exports;
 	}
 });
 Object.defineProperty(exports, "DS", {
 	enumerable: true,
 	get: function() {
-		return require_index$10.dataStructure_exports;
+		return require_index$12.dataStructure_exports;
 	}
 });
 Object.defineProperty(exports, "DString", {
 	enumerable: true,
 	get: function() {
-		return require_index$7.string_exports;
+		return require_index$8.string_exports;
 	}
 });
 Object.defineProperty(exports, "DTuple", {
 	enumerable: true,
 	get: function() {
-		return require_index$11.tuple_exports;
+		return require_index$13.tuple_exports;
 	}
 });
 Object.defineProperty(exports, "E", {
 	enumerable: true,
 	get: function() {
-		return require_index$5.either_exports;
+		return require_index$6.either_exports;
 	}
 });
 Object.defineProperty(exports, "G", {
 	enumerable: true,
 	get: function() {
-		return require_index$4.generator_exports;
+		return require_index$5.generator_exports;
 	}
 });
 Object.defineProperty(exports, "I", {
 	enumerable: true,
 	get: function() {
-		return require_index$14.invocation_exports;
+		return require_index$16.invocation_exports;
 	}
 });
 exports.InvalidBytesInStringError = require_stringToBytes.InvalidBytesInStringError;
@@ -206,14 +208,14 @@ exports.InvalidMillisecondInStringError = require_stringToMillisecond.InvalidMil
 Object.defineProperty(exports, "M", {
 	enumerable: true,
 	get: function() {
-		return require_index$12.modeling_exports;
+		return require_index$14.modeling_exports;
 	}
 });
 exports.MissingBuilderMethodsError = require_builder.MissingBuilderMethodsError;
 Object.defineProperty(exports, "N", {
 	enumerable: true,
 	get: function() {
-		return require_index$9.number_exports;
+		return require_index$11.number_exports;
 	}
 });
 Object.defineProperty(exports, "O", {
@@ -225,19 +227,19 @@ Object.defineProperty(exports, "O", {
 Object.defineProperty(exports, "P", {
 	enumerable: true,
 	get: function() {
-		return require_index$13.pattern_exports;
+		return require_index$15.pattern_exports;
 	}
 });
 Object.defineProperty(exports, "S", {
 	enumerable: true,
 	get: function() {
-		return require_index$7.string_exports;
+		return require_index$8.string_exports;
 	}
 });
 Object.defineProperty(exports, "T", {
 	enumerable: true,
 	get: function() {
-		return require_index$11.tuple_exports;
+		return require_index$13.tuple_exports;
 	}
 });
 exports.TheFormData = require_formData.TheFormData;
@@ -268,6 +270,7 @@ exports.falsy = require_falsy.falsy;
 exports.forward = require_forward.forward;
 exports.forwardAsserts = require_forwardAsserts.forwardAsserts;
 exports.forwardLog = require_forwardLog.forwardLog;
+exports.infer = require_index$3.infer;
 exports.innerPipe = require_innerPipe.innerPipe;
 exports.instanceOf = require_instanceOf.instanceOf;
 exports.isType = require_isType.isType;
@@ -286,6 +289,7 @@ exports.preparePipe = require_preparePipe.preparePipe;
 exports.promiseAll = require_promiseAll.promiseAll;
 exports.promiseObject = require_promiseObject.promiseObject;
 exports.queueKind = require_queue.queueKind;
+exports.removeConstraint = require_remove.removeConstraint;
 exports.shameOnYou = require_index$2.shameOnYou;
 exports.simpleClone = require_simpleClone.simpleClone;
 exports.stringToBytes = require_stringToBytes.stringToBytes;

package/dist/index.mjs

@@ -14,6 +14,8 @@ import { callThen } from "./common/callThen.mjs";
 import { object_exports } from "./object/index.mjs";
 import { clone } from "./common/clone.mjs";
 import { cast, shameOnYou } from "./common/constraint/cast/index.mjs";
+import { infer } from "./common/constraint/infer/index.mjs";
+import { removeConstraint } from "./common/constraint/remove.mjs";
 import { detachObjectMethod } from "./common/detachObjectMethod.mjs";
 import { createEnum } from "./common/enum.mjs";
 import { equal } from "./common/equal.mjs";
@@ -59,12 +61,12 @@ import { when } from "./common/when.mjs";
 import { whenElse } from "./common/whenElse.mjs";
 import { whenNot } from "./common/whenNot.mjs";
 import { common_exports } from "./common/index.mjs";
+import { path_exports } from "./path/index.mjs";
 import { number_exports } from "./number/index.mjs";
 import { dataStructure_exports } from "./dataStructure/index.mjs";
 import { tuple_exports } from "./tuple/index.mjs";
 import { modeling_exports } from "./modeling/index.mjs";
 import { pattern_exports } from "./pattern/index.mjs";
 import { invocation_exports } from "./invocation/index.mjs";
-import { path_exports } from "./path/index.mjs";
 import { printer_exports } from "./printer/index.mjs";
-export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { array_exports as A, AssertsError, chrono_exports as C, array_exports as DArray, chrono_exports as DChrono, common_exports as DCommon, dataStructure_exports as DDataStructure, either_exports as DEither, generator_exports as DGenerator, invocation_exports as DInvocation, kind_exports as DKind, modeling_exports as DModeling, number_exports as DNumber, object_exports as DObject, path_exports as DPath, pattern_exports as DPattern, printer_exports as DPrinter, dataStructure_exports as DS, string_exports as DString, tuple_exports as DTuple, either_exports as E, generator_exports as G, invocation_exports as I, InvalidBytesInStringError, InvalidMillisecondInStringError, modeling_exports as M, MissingBuilderMethodsError, number_exports as N, object_exports as O, pattern_exports as P, string_exports as S, tuple_exports as T, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, infer, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/invocation/flow/base.d.ts

@@ -1,12 +1,17 @@
-import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult } from './controller';
-import { DKind } from '../../index.ts';
+import { FlowControllerExit, FlowControllerResult, flowControllerExitKind, FlowControllerPreviousFunctionResult, UnwrapFlowControllerResult } from './controller';
 import * as DCommon from '../../common';
+import type * as DKind from '../../kind';
 type ComputeLastUsableValue<GenericAccumulator extends DCommon.AnyTuple> = GenericAccumulator extends [
     ...infer InferredRest,
     infer InferredLast
 ] ? InferredLast extends FlowControllerResult<infer InferredFlowControllerResult> ? Exclude<Awaited<InferredFlowControllerResult>, FlowControllerPreviousFunctionResult | FlowControllerExit> extends infer InferredOutputValue ? DCommon.HasSomething<InferredOutputValue> extends true ? InferredOutputValue : InferredRest extends DCommon.AnyTuple ? ComputeLastUsableValue<InferredRest> : never : never : InferredLast : never;
 type Pipe<GenericAccumulator extends DCommon.AnyTuple, GenericOutput extends unknown> = (this: never, input: Awaited<ComputeLastUsableValue<GenericAccumulator>>) => GenericOutput;
-type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (GenericAccumulator[number] extends infer InferredPipeResult ? InferredPipeResult extends FlowControllerResult<infer InferredResult> ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : never : never : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, Promise<any>> extends true ? Promise<Awaited<InferredResult>> : InferredResult : never, any>;
+type IsMaybePromise<GenericAccumulator extends DCommon.AnyTuple> = {
+    [Index in keyof GenericAccumulator]: UnwrapFlowControllerResult<GenericAccumulator[Index]> extends infer InferredResult ? DCommon.IsExtends<InferredResult, Promise<unknown>> extends true ? false : DCommon.ContainExtends<InferredResult, Promise<any>> : never;
+}[number] extends false ? false : true;
+type ComputeTypeOutput<GenericAccumulator extends DCommon.AnyTuple> = Extract<(ComputeLastUsableValue<GenericAccumulator> | (UnwrapFlowControllerResult<GenericAccumulator[number]> extends infer InferredResult ? InferredResult extends FlowControllerExit ? DKind.GetValue<typeof flowControllerExitKind, InferredResult> : InferredResult extends Promise<infer InferredExit extends FlowControllerExit> ? Promise<DKind.GetValue<typeof flowControllerExitKind, InferredExit>> : InferredResult extends Promise<unknown> ? Promise<never> : never : never)) extends infer InferredResult ? DCommon.Or<[
+    DCommon.ContainExtends<InferredResult, Promise<any>>
+]> extends true ? IsMaybePromise<GenericAccumulator> extends true ? DCommon.MaybePromise<Awaited<InferredResult>> : Promise<Awaited<InferredResult>> : InferredResult : never, any>;
 export declare function flow<const GenericInput extends unknown, const GenericOutput1 extends unknown>(pipe1: Pipe<[
     GenericInput
 ], GenericOutput1>): (input: GenericInput) => DCommon.BreakGenericLink<Extract<ComputeTypeOutput<[

package/dist/invocation/flow/controller/base.d.ts

@@ -11,6 +11,7 @@ export type FlowControllerPreviousFunctionResult = DCommon.MaybePromise<(DCommon
 export interface FlowControllerResult<GenericResult extends unknown> {
     readonly [FlowControllerResultSymbol]: GenericResult;
 }
+export type UnwrapFlowControllerResult<GenericValue extends unknown> = GenericValue extends FlowControllerResult<infer InferredResult> ? InferredResult : GenericValue;
 export interface FlowController<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DKind.Kind<typeof flowControllerKind> {
     (this: never, input: GenericInput): FlowControllerResult<GenericOutput>;
     exec(previousFunction: () => FlowControllerPreviousFunctionResult): (FlowControllerPreviousFunctionResult | GenericOutput | DCommon.MergePromise<FlowControllerPreviousFunctionResult | GenericOutput>);

package/dist/invocation/flow/controller/defaults/aborter.cjs

@@ -0,0 +1,38 @@
+const require_parentClass = require("../../../../kind/parentClass.cjs");
+const require_create = require("../../../../either/left/create.cjs");
+const require_stringToMillisecond = require("../../../../common/stringToMillisecond.cjs");
+const require_kind = require("../../../kind.cjs");
+const require_base = require("../base.cjs");
+//#region scripts/invocation/flow/controller/defaults/aborter.ts
+const flowControllerAborterKind = require_kind.createKind("flow-controller-aborter");
+var AbortErrorFlowController = class extends require_parentClass.parentClass(require_kind.createKind("abort-error-flow-controller"), Error) {
+	abortController;
+	constructor(abortController) {
+		super(null, "Flow is aborted by FlowControllerAborter.");
+		this.abortController = abortController;
+	}
+};
+const aborter = require_base.createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
+	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : require_stringToMillisecond.stringToMillisecond(params.timeout);
+	return init(async (previousFunction) => {
+		const result = previousFunction();
+		if (require_base.flowControllerExitKind.has(result)) return result;
+		aborter?.abort(new AbortErrorFlowController(aborter));
+		const currentAborter = new AbortController();
+		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
+		try {
+			const abortResult = await theFunction(result, currentAborter);
+			if (currentAborter.signal.aborted === true) return exitFlow(require_create.left("signal-aborted", currentAborter.signal.reason));
+			return abortResult;
+		} catch (error) {
+			if (error instanceof AbortErrorFlowController) return exitFlow(require_create.left("signal-aborted", currentAborter.signal.reason));
+			throw error;
+		}
+	});
+});
+//#endregion
+exports.AbortErrorFlowController = AbortErrorFlowController;
+exports.aborter = aborter;
+exports.flowControllerAborterKind = flowControllerAborterKind;

package/dist/invocation/flow/controller/defaults/aborter.d.ts

@@ -0,0 +1,17 @@
+import { FlowController } from '../base';
+import * as DCommon from '../../../../common';
+import * as DKind from '../../../../kind';
+import * as DEither from '../../../../either';
+export declare const flowControllerAborterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-aborter", unknown>>;
+export interface FlowControllerAborter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<Awaited<GenericOutput> | DEither.Left<"signal-aborted", AbortErrorFlowController>>> & DKind.Kind<typeof flowControllerAborterKind>> {
+}
+declare const AbortErrorFlowController_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/abort-error-flow-controller", unknown>>, ErrorConstructor>;
+export declare class AbortErrorFlowController extends AbortErrorFlowController_base {
+    abortController: AbortController;
+    constructor(abortController: AbortController);
+}
+export interface FlowControllerAborterParams {
+    timeout?: DCommon.TimeInString;
+}
+export declare const aborter: <GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: GenericInput, aborter: AbortController) => GenericOutput, params?: FlowControllerAborterParams) => FlowControllerAborter<GenericInput, GenericOutput>;
+export {};