@oscarpalmer/atoms 0.209.0 → 0.211.0

package/dist/index.mjs

@@ -2737,7 +2737,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -2756,93 +2756,36 @@ const PLAN_SYMBOL = Symbol("plan");
 const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
 const PLAN_TYPE_PLAN_SYNC = "plan";
 //#endregion
-//#region src/plan/index.ts
-function AsyncPlan(generator) {
-	this[PLAN_SYMBOL] = {
-		generator,
-		type: PLAN_TYPE_PLAN_ASYNC
-	};
-}
-AsyncPlan.prototype[Symbol.asyncIterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-AsyncPlan.prototype.run = runAsyncPlan;
-function Plan(generator) {
-	this[PLAN_SYMBOL] = {
-		generator,
-		type: PLAN_TYPE_PLAN_SYNC
-	};
-}
-Plan.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-Plan.prototype.run = runPlan;
-function asyncExecute(callback) {
-	return asyncAttempt(async () => {
-		const generator = callback();
-		let lastValue;
-		while (true) {
-			const next = await generator.next();
-			const { done } = next;
-			let value = next.value;
-			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.value;
-			lastValue = value;
-			if (done === true) break;
-		}
-		return lastValue;
-	});
-}
+//#region src/internal/plan.ts
 /**
-* Create a plan for an asynchronous generator function
+* Create an immediately failing generator
 *
-* @param generator Generator to plan for
-* @returns Generator plan
+* @param reason Failure reason
+* @returns Failing generator
 */
-function asyncPlan(generator) {
-	if (!isAsyncGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
-	return new AsyncPlan(generator);
-}
-async function asyncRun(input) {
-	if (isAsyncPlan(input)) return input.run();
-	if (!isAsyncGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
-	return asyncExecute(input);
-}
-function execute(callback) {
-	return attempt(() => {
-		const generator = callback();
-		let lastValue;
-		while (true) {
-			const next = generator.next();
-			const { done } = next;
-			let { value } = next;
-			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.value;
-			lastValue = value;
-			if (done === true) break;
-		}
-		return lastValue;
-	});
+function fail(reason) {
+	return (function* () {
+		yield;
+		throw reason;
+	})();
 }
 /**
-* Is the value an asynchronous plan?
+* Is the value an asynchronous generator function?
 *
 * @param value Value to check
-* @returns `true` if the value is an asynchronous plan, otherwise `false`
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
 */
-function isAsyncPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
 }
 /**
-* Is the value an asynchronous generator function?
+* Is the value an asynchronous plan?
 *
 * @param value Value to check
-* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
 */
-function isAsyncGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
 }
 /**
 * Is the value a generator function?
@@ -2869,28 +2812,134 @@ function isPlanInstance(type, value) {
 	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
 }
 /**
-* Create a plan for a generator function
+* Create an immediately succeeding generator
 *
-* @param generator Generator to plan for
-* @returns Generator plan
+* @param value Success value
+* @returns Succeeding generator
 */
-function plan(generator) {
-	if (!isGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
-	return new Plan(generator);
+function succeed(value) {
+	return (function* () {
+		yield;
+		return value;
+	})();
+}
+//#endregion
+//#region src/plan/generate.ts
+async function asyncGenerate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = await generator.next(lastValue);
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done === true) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		await generator?.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+function generate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = generator.next(lastValue);
+			const done = next.done === true;
+			const { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+//#endregion
+//#region src/plan/result.ts
+function asyncAttemptRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.attempt(...parameters);
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function attemptRun(input, ...parameters) {
+	if (isPlan(input)) return input.attempt(...parameters);
+	if (isGenerator(input)) return attempt(() => generate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function attemptRunAsyncPlan(...parameters) {
+	return asyncAttempt(() => this.run(...parameters));
 }
-function run(input) {
-	if (isPlan(input)) return input.run();
-	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
-	return execute(input);
+function attemptRunPlan(...parameters) {
+	return attempt(() => this.run(...parameters));
 }
-function runAsyncPlan() {
-	return asyncExecute(this[PLAN_SYMBOL].generator);
+attemptRun.async = asyncAttemptRun;
+//#endregion
+//#region src/plan/run.ts
+function asyncRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.run(...parameters);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function run(input, ...parameters) {
+	if (isPlan(input)) return input.run(...parameters);
+	if (isGenerator(input)) return generate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runPlan() {
-	return execute(this[PLAN_SYMBOL].generator);
+function runAsyncPlan(...parameters) {
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
 }
-plan.async = asyncPlan;
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL].generator, parameters);
+}
+asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;
+run.attempt = attemptRun;
+//#endregion
+//#region src/plan/index.ts
+function AsyncPlan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_ASYNC
+	};
+}
+AsyncPlan.prototype[Symbol.asyncIterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
+AsyncPlan.prototype.run = runAsyncPlan;
+function Plan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
+}
+Plan.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+Plan.prototype.attempt = attemptRunPlan;
+Plan.prototype.run = runPlan;
+function plan(generator) {
+	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
+	if (isGenerator(generator)) return new Plan(generator);
+	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+}
 //#endregion
 //#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
@@ -6992,4 +7041,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncPlan, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/aborter.d.mts

@@ -2,8 +2,8 @@ import { GenericCallback } from "../models.mjs";
 //#region src/internal/aborter.d.ts
 export type Aborter = {
   callback: GenericCallback;
+  cancel(): void;
   signal: AbortSignal;
-  cancel: () => void;
 };
 export declare function createAborter(value: unknown, onAbort: () => void): Aborter | undefined;
 //#endregion

package/dist/internal/models/plan.model.d.mts

@@ -1,55 +1,76 @@
-import { Result } from "./result.model.mjs";
+import { Err, Ok, Result } from "./result.model.mjs";
 //#region src/internal/models/plan.model.d.ts
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
-export type AsyncPlan<Value, Error = unknown> = {
+export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
   /**
    * Get the asynchronous generator for the plan
    *
    * @returns Asynchronous generator
    */
-  [Symbol.asyncIterator]: () => AsyncGenerator<unknown, Value, unknown>;
+  [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
+  /**
+   * Attempt to run the plan to completion
+   *
+   * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+   *
+   * @returns Promised result
+   */
+  attempt(...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
+   * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Promise<Result<Value, Error>>;
+  run(...parameters: Parameters): Promise<PlanResult<Returned>>;
 };
 type AsyncPlanState = {
-  generator: () => AsyncGenerator;
+  generator(...parameters: unknown[]): AsyncGenerator;
 } & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
 type BaseState<Type extends PlanType> = {
   type: Type;
 };
 export type InternalAsyncPlan = {
   [PLAN_SYMBOL]: AsyncPlanState;
-} & AsyncPlan<never, never>;
+} & AsyncPlan<never, never, unknown[]>;
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
-} & Plan<never, never>;
+} & Plan<never, never, unknown[]>;
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
-export type Plan<Value, Error = unknown> = {
+export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
   /**
    * Get the generator for the plan
    *
    * @returns Generator
    */
-  [Symbol.iterator]: () => Generator<unknown, Value, unknown>;
+  [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
+  /**
+   * Attempt to run the plan to completion
+   *
+   * _Returns a {@link Result} instead of a raw value or throwing an error_
+   *
+   * @returns Result
+   */
+  attempt(...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
+   * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Result<Value, Error>;
+  run(...parameters: Parameters): PlanResult<Returned>;
 };
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : Original extends Result<infer _, infer Error> ? Error : never;
+export type PlanError<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned> | Error;
+export type PlanResult<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned extends Result<infer Value, infer _> ? Value : Returned;
 type PlanState = {
-  generator: () => Generator;
+  generator(...parameters: unknown[]): Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
-export type PlanType = "asyncPlan" | "plan";
+export type PlanType = "asyncPlan" | "plan" | "stop";
 export declare const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
 export declare const GENERATOR_NAME_SYNC = "GeneratorFunction";
 export declare const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";

package/dist/internal/models/result.model.d.mts

@@ -43,14 +43,14 @@ export type ResultMatch<Value, Returned, E = Error> = {
    * @param original Original error, if available
    * @returns Value to return
    */
-  error: (error: E, original?: Error) => Returned;
+  error(error: E, original?: Error): Returned;
   /**
    * Callback for ok result
    *
    * @param value Ok value
    * @returns Value to return
    */
-  ok: (value: Value) => Returned;
+  ok(value: Value): Returned;
 };
 /**
  * Unwrap a result value

package/dist/internal/plan.d.mts

@@ -0,0 +1,45 @@
+import { AsyncPlan, Plan } from "./models/plan.model.mjs";
+//#region src/internal/plan.d.ts
+/**
+ * Create an immediately failing generator
+ *
+ * @param reason Failure reason
+ * @returns Failing generator
+ */
+export declare function fail<Reason>(reason: Reason): Generator<unknown, never>;
+/**
+ * Is the value an asynchronous generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous generator function, otherwise `false`
+ */
+export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
+/**
+ * Is the value an asynchronous plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ */
+export declare function isAsyncPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is AsyncPlan<Yielded, Returned, Parameters>;
+/**
+ * Is the value a generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a generator function, otherwise `false`
+ */
+export declare function isGenerator(value: unknown): value is () => Generator;
+/**
+ * Is the value a plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a plan, otherwise `false`
+ */
+export declare function isPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is Plan<Yielded, Returned, Parameters>;
+/**
+ * Create an immediately succeeding generator
+ *
+ * @param value Success value
+ * @returns Succeeding generator
+ */
+export declare function succeed<Value>(value: Value): Generator<unknown, Value>;
+//#endregion

package/dist/internal/plan.mjs

@@ -0,0 +1,70 @@
+import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "./models/plan.model.mjs";
+//#region src/internal/plan.ts
+/**
+* Create an immediately failing generator
+*
+* @param reason Failure reason
+* @returns Failing generator
+*/
+function fail(reason) {
+	return (function* () {
+		yield;
+		throw reason;
+	})();
+}
+/**
+* Is the value an asynchronous generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
+}
+/**
+* Is the value an asynchronous plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
+*/
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_SYNC, value);
+}
+function isGeneratorInstance(name, value) {
+	return typeof value === "function" && value !== null && value.constructor.name === name && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+/**
+* Create an immediately succeeding generator
+*
+* @param value Success value
+* @returns Succeeding generator
+*/
+function succeed(value) {
+	return (function* () {
+		yield;
+		return value;
+	})();
+}
+//#endregion
+export { fail, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, succeed };

package/dist/internal/subscription.d.mts

@@ -65,14 +65,14 @@ export type Subscriptions<Value = unknown> = {
   /**
    * Clear all subscriptions
    */
-  clear: () => void;
+  clear(): void;
   /**
    * Create _(or retrieve)_ a subscription
    *
    * @param parameters Subscription parameters
    * @returns Tuple holding subsccription and existing boolean
    */
-  create: (parameters: SubscriptionParameters) => [Subscription, boolean];
+  create(parameters: SubscriptionParameters): [Subscription, boolean];
 };
 /**
  * Parameters for creating a subscription store

package/dist/internal/value/handlers.d.mts

@@ -4,9 +4,9 @@ type BaseHandler = {
   handlers: WeakMap<WeakKey, string | GenericCallback>;
   options: BaseHandlerOptions;
   owner: GenericCallback;
-  deregister: (constructor: Constructor) => void;
-  get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
-  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+  deregister(constructor: Constructor): void;
+  get(first: unknown, second: unknown): string | GenericCallback | undefined;
+  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 type BaseHandlerOptions = {
   callback: GenericCallback;

package/dist/internal/value/set.mjs

@@ -21,7 +21,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}

package/dist/models.d.mts

@@ -90,7 +90,7 @@ export type OnceAsync<Callback extends GenericAsyncCallback> = {
    * @param parameters Callback parameters
    * @returns Call result
    */
-  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 } & OnceProperties;
 /**
  * A callback function that can only be called once, returning the same value on subsequent calls
@@ -102,7 +102,7 @@ export type Once<Callback extends GenericCallback> = {
    * @param parameters Callback parameters
    * @returns Call result
    */
-  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 } & OnceProperties;
 type OnceProperties = {
   /**
@@ -116,7 +116,7 @@ type OnceProperties = {
   /**
    * Clear the callback's cached value
    */
-  clear: () => void;
+  clear(): void;
 };
 /**
  * A generic object

package/dist/plan/generate.d.mts

@@ -0,0 +1,4 @@
+//#region src/plan/generate.d.ts
+export declare function asyncGenerate(callback: (...parameters: unknown[]) => AsyncGenerator, parameters: unknown[]): Promise<unknown>;
+export declare function generate(callback: (...parameters: unknown[]) => Generator, parameters: unknown[]): unknown;
+//#endregion

package/dist/plan/generate.mjs

@@ -0,0 +1,50 @@
+import { isError } from "../internal/result/misc.mjs";
+//#region src/plan/generate.ts
+async function asyncGenerate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = await generator.next(lastValue);
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done === true) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		await generator?.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+function generate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = generator.next(lastValue);
+			const done = next.done === true;
+			const { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+//#endregion
+export { asyncGenerate, generate };