@oscarpalmer/atoms 0.215.0 → 0.217.0

package/dist/index.mjs

@@ -2768,57 +2768,21 @@ function setValue(data, path, value, ignoreCase) {
 }
 //#endregion
 //#region src/models/plan.model.ts
-const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
-const GENERATOR_NAME_SYNC = "GeneratorFunction";
+const GENERATOR_FUNCTION_TYPE_ASYNC = "[object AsyncGeneratorFunction]";
+const GENERATOR_FUNCTION_TYPE_SYNC = "[object GeneratorFunction]";
+const GENERATOR_TYPE_ASYNC = "[object AsyncGenerator]";
+const GENERATOR_TYPE_SYNC = "[object Generator]";
+const PLAN_FAILURE_ASYNC = "asyncFailure";
+const PLAN_FAILURE_SYNC = "failure";
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+const PLAN_STEP_ASYNC = "asyncStep";
+const PLAN_STEP_SYNC = "step";
+const PLAN_SUCCESS_ASYNC = "asyncSuccess";
+const PLAN_SUCCESS_SYNC = "success";
 const PLAN_SYMBOL = Symbol("plan");
-const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
-const PLAN_TYPE_PLAN_SYNC = "plan";
-//#endregion
-//#region src/plan/is.ts
-/**
-* 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;
-}
+const PLAN_TYPE_ASYNC = "asyncPlan";
+const PLAN_TYPE_SYNC = "plan";
 //#endregion
 //#region src/models/aborter.model.ts
 const ABORTER_EVENT = "abort";
@@ -2835,7 +2799,7 @@ function createAborter(value, onAbort) {
 	};
 }
 //#endregion
-//#region src/plan/generate.ts
+//#region src/internal/plan/plan.generate.ts
 async function asyncGenerate(input, unwrap, first, second) {
 	const aborter = createAborter(second ?? first, noop);
 	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
@@ -2893,46 +2857,164 @@ function generate(input, parameters, unwrap) {
 	throw lastValue;
 }
 //#endregion
+//#region src/internal/plan/index.ts
+function attemptRunPlan(...parameters) {
+	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
+}
+function getGenerator() {
+	return this[PLAN_SYMBOL].generator();
+}
+function runAsyncPlan(first, second) {
+	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL], parameters, false);
+}
+//#endregion
+//#region src/plan/is.ts
+/**
+* Is the value an asynchronous, immediately failing plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous, immediately failing plan, otherwise `false`
+*/
+function isAsyncFailure(value) {
+	return isPlanInstance(PLAN_FAILURE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous generator?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_TYPE_ASYNC, value);
+}
+/**
+* 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 isAsyncGeneratorFunction(value) {
+	return isGeneratorInstance(GENERATOR_FUNCTION_TYPE_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_ASYNC, value);
+}
+/**
+* Is the value an asynchronous step?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous step, otherwise `false`
+*/
+function isAsyncStep(value) {
+	return isPlanInstance(PLAN_STEP_ASYNC, value);
+}
+/**
+* Is the value an asynchronous, immediately successful plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous, immediately successful plan, otherwise `false`
+*/
+function isAsyncSuccess(value) {
+	return isPlanInstance(PLAN_SUCCESS_ASYNC, value);
+}
+/**
+* Is the value an immediately failing plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an immediately failing plan, otherwise `false`
+*/
+function isFailure(value) {
+	return isPlanInstance(PLAN_FAILURE_SYNC, value);
+}
+/**
+* Is the value a generator?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator, otherwise `false`
+*/
+function isGenerator(value) {
+	return isGeneratorInstance(GENERATOR_TYPE_SYNC, value);
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGeneratorFunction(value) {
+	return isGeneratorInstance(GENERATOR_FUNCTION_TYPE_SYNC, value);
+}
+function isGeneratorInstance(type, value) {
+	return Object.prototype.toString.call(value) === type;
+}
+/**
+* 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_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+/**
+* Is the value a step?
+*
+* @param value Value to check
+* @returns `true` if the value is a step, otherwise `false`
+*/
+function isStep(value) {
+	return isPlanInstance(PLAN_STEP_SYNC, value);
+}
+/**
+* Is the value an immediately successful plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an immediately successful plan, otherwise `false`
+*/
+function isSuccess(value) {
+	return isPlanInstance(PLAN_SUCCESS_SYNC, value);
+}
+//#endregion
 //#region src/plan/result.ts
 function asyncAttemptRun(input, first, second) {
 	let generator;
 	if (isAsyncPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isAsyncGenerator(input)) generator = input;
+	else if (isAsyncGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return asyncAttempt(() => asyncGenerate(generator, true, first, second));
 }
 function attemptRun(input, ...parameters) {
 	let generator;
 	if (isPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isGenerator(input)) generator = input;
+	else if (isGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return attempt(() => generate(generator, parameters, true));
 }
-function attemptRunAsyncPlan(first, second) {
-	return asyncAttemptRun(this, first, second);
-}
-function attemptRunPlan(...parameters) {
-	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
-}
 attemptRun.async = asyncAttemptRun;
 //#endregion
 //#region src/plan/run.ts
 function asyncRun(input, first, second) {
 	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
-	if (isAsyncGenerator(input)) return asyncGenerate(input, false, first, second);
+	if (isAsyncGeneratorFunction(input)) return asyncGenerate(input, false, first, second);
 	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, false);
+	if (isGeneratorFunction(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan(first, second) {
-	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
-}
-function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL], parameters, false);
-}
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;
 run.attempt = attemptRun;
@@ -2941,66 +3023,144 @@ run.attempt = attemptRun;
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
-		type: PLAN_TYPE_PLAN_ASYNC
+		type: PLAN_TYPE_ASYNC
 	};
 }
-AsyncPlan.prototype[Symbol.asyncIterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
+AsyncPlan.prototype[Symbol.asyncIterator] = getGenerator;
 AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
 AsyncPlan.prototype.run = runAsyncPlan;
 function Plan(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
-		type: PLAN_TYPE_PLAN_SYNC
+		type: PLAN_TYPE_SYNC
 	};
 }
-Plan.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
+Plan.prototype[Symbol.iterator] = getGenerator;
 Plan.prototype.attempt = attemptRunPlan;
 Plan.prototype.run = runPlan;
+function attemptRunAsyncPlan(first, second) {
+	return asyncAttemptRun(this, first, second);
+}
 function plan(generator) {
-	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
-	if (isGenerator(generator)) return new Plan(generator);
+	if (isAsyncGeneratorFunction(generator)) return new AsyncPlan(generator);
+	if (isGeneratorFunction(generator)) return new Plan(generator);
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
 //#region src/plan/misc.ts
-function PlanFailure(generator) {
-	this[PLAN_SYMBOL] = { generator };
+function AsyncFailure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_ASYNC
+	};
 }
-PlanFailure.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-function PlanSuccess(generator) {
-	this[PLAN_SYMBOL] = { generator };
+AsyncFailure.prototype[Symbol.asyncIterator] = getGenerator;
+function AsyncSuccess(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_ASYNC
+	};
+}
+AsyncSuccess.prototype[Symbol.asyncIterator] = getGenerator;
+function Failure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_SYNC
+	};
+}
+Failure.prototype[Symbol.iterator] = getGenerator;
+function Success(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_SYNC
+	};
+}
+Success.prototype[Symbol.iterator] = getGenerator;
+function asyncFail(value) {
+	return new AsyncFailure(async function* () {
+		yield error(await (typeof value === "function" ? value() : value));
+	});
+}
+function asyncSucceed(value) {
+	return new AsyncSuccess(async function* () {
+		return typeof value === "function" ? value() : value;
+	});
 }
-PlanSuccess.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-/**
-* Create an immediately failing plan
-*
-* @param value Failure value
-* @returns Plan failure
-*/
 function fail(value) {
-	return new PlanFailure(function* () {
-		yield error(value);
+	return new Failure(function* () {
+		yield error(typeof value === "function" ? value() : value);
 	});
 }
-/**
-* Create an immediately succeeding plan
-*
-* @param value Success value
-* @returns Plan success
-*/
 function succeed(value) {
-	return new PlanSuccess(function* () {
-		return value;
+	return new Success(function* () {
+		return typeof value === "function" ? value() : value;
+	});
+}
+fail.async = asyncFail;
+succeed.async = asyncSucceed;
+//#endregion
+//#region src/plan/use.ts
+function AsyncStep(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_ASYNC
+	};
+}
+AsyncStep.prototype[Symbol.asyncIterator] = getGenerator;
+function Step(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_SYNC
+	};
+}
+Step.prototype[Symbol.iterator] = getGenerator;
+function asyncUse(value) {
+	return new AsyncStep(async function* () {
+		let actual = value;
+		if (typeof actual === "function") actual = actual();
+		actual = await actual;
+		if (typeof actual === "function") throw new Error();
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isAsyncGenerator(actual) || isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
 	});
 }
+function use(value) {
+	validateUseInput(value, false);
+	return new Step(function* () {
+		let actual = value;
+		if (typeof actual === "function") {
+			actual = actual();
+			validateUseInput(actual, true);
+		}
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
+	});
+}
+function validateUseInput(value, resolved) {
+	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error();
+	if (resolved && typeof value === "function") throw new Error();
+}
+use.async = asyncUse;
 //#endregion
 //#region src/models/promise.model.ts
 /**
@@ -7111,4 +7271,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, 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, attemptRunAsyncPlan, attemptRunPlan, 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, runAsyncPlan, runPlan, 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 };
+export { CancelablePromise, Logger, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFail, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncSucceed, asyncThrottle, asyncUse, 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, isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncOnce, isAsyncPlan, isAsyncStep, isAsyncSuccess, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, 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, isStep, isSubscription, isSubscriptions, isSuccess, 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, use, words };

package/dist/internal/plan/index.d.mts

@@ -0,0 +1,7 @@
+import { GenericPlanItem, InternalAsyncPlan, InternalPlan } from "../../models/plan.model.mjs";
+//#region src/internal/plan/index.d.ts
+export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+export declare function getGenerator(this: GenericPlanItem): AsyncGenerator | Generator;
+export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
+export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+//#endregion

package/dist/internal/plan/index.mjs

@@ -0,0 +1,18 @@
+import { attempt } from "../result/attempt.mjs";
+import { PLAN_SYMBOL } from "../../models/plan.model.mjs";
+import { asyncGenerate, generate } from "./plan.generate.mjs";
+//#region src/internal/plan/index.ts
+function attemptRunPlan(...parameters) {
+	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
+}
+function getGenerator() {
+	return this[PLAN_SYMBOL].generator();
+}
+function runAsyncPlan(first, second) {
+	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL], parameters, false);
+}
+//#endregion
+export { attemptRunPlan, getGenerator, runAsyncPlan, runPlan };

package/dist/{plan/generate.d.mts → internal/plan/plan.generate.d.mts}

@@ -1,5 +1,5 @@
-import { AsyncPlanState, PlanState } from "../models/plan.model.mjs";
-//#region src/plan/generate.d.ts
+import { AsyncPlanState, PlanState } from "../../models/plan.model.mjs";
+//#region src/internal/plan/plan.generate.d.ts
 export declare function asyncGenerate(input: AsyncPlanState | ((...args: unknown[]) => AsyncGenerator), unwrap: boolean, first?: unknown, second?: unknown): Promise<unknown>;
 export declare function generate(input: PlanState | ((...parameters: unknown[]) => Generator), parameters: unknown[], unwrap: boolean): unknown;
 //#endregion

package/dist/{plan/generate.mjs → internal/plan/plan.generate.mjs}

@@ -1,7 +1,7 @@
-import { noop } from "../internal/function/misc.mjs";
-import { createAborter } from "../internal/aborter.mjs";
-import { isError, isOk } from "../internal/result/misc.mjs";
-//#region src/plan/generate.ts
+import { noop } from "../function/misc.mjs";
+import { createAborter } from "../aborter.mjs";
+import { isError, isOk } from "../result/misc.mjs";
+//#region src/internal/plan/plan.generate.ts
 async function asyncGenerate(input, unwrap, first, second) {
 	const aborter = createAborter(second ?? first, noop);
 	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;

package/dist/models/color.model.d.mts

@@ -307,4 +307,5 @@ export type ColorValue = string | HSLColor | HWBColor | RGBColor;
  * Extended color values
  */
 export type ColorValueExtended = ColorValue | HSLAColor | HWBAColor | RGBAColor;
-//#endregion
+//#endregion
+export {};

package/dist/models/function/once.model.d.mts

@@ -73,4 +73,5 @@ export declare const ONCE_PROPERTY = "$once";
 export declare const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 export declare const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
 export declare const ONCE_SYMBOL: unique symbol;
-//#endregion
+//#endregion
+export {};

package/dist/models/index.d.mts

@@ -124,4 +124,5 @@ export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUn
  * A function that unsubscribes from a subscription
  */
 export type Unsubscriber = () => void;
-//#endregion
+//#endregion
+export {};