@oscarpalmer/atoms 0.221.0 → 0.223.0

package/dist/plan/run.d.mts

@@ -1,6 +1,5 @@
-import { AsyncPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
+import { AsyncPlan, Plan, PlannedReturned } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
-//#region src/plan/run.d.ts
 /**
  * Run an asynchronous generator to completion
  *
@@ -9,7 +8,7 @@ import { asyncAttemptRun, attemptRun } from "./result.mjs";
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run an asynchronous generator to completion
  *
@@ -17,7 +16,7 @@ export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
@@ -26,7 +25,7 @@ export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenera
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
@@ -34,7 +33,7 @@ export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]
  * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlannedReturned<Returned>>;
 /**
  * Run a generator to completion
  *
@@ -42,7 +41,7 @@ export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Ret
  * @param parameters Parameters for starting the run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlannedReturned<Returned>;
 /**
  * Run a plan to completion
  *
@@ -50,12 +49,11 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * @param parameters Parameters for starting the run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlannedReturned<Returned>;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
 }
 export declare namespace run {
   export var async: typeof asyncRun;
   export var attempt: typeof attemptRun;
-}
-//#endregion
+}

package/dist/plan/run.mjs

@@ -1,8 +1,8 @@
-import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
 import { asyncGenerate, generate } from "../internal/plan/plan.generate.mjs";
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
 import { isAsyncGeneratorFunction, isAsyncPlan, isGeneratorFunction, isPlan } from "./is.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
-//#region src/plan/run.ts
+// src/plan/run.ts
 function asyncRun(input, first, second) {
 	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
 	if (isAsyncGeneratorFunction(input)) return asyncGenerate(input, false, first, second);
@@ -16,5 +16,4 @@ function run(input, ...parameters) {
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;
 run.attempt = attemptRun;
-//#endregion
 export { asyncRun, run };

package/dist/plan/use.d.mts

@@ -1,5 +1,4 @@
 import { AsyncStep, AsyncStepValue, Step, StepValue } from "../models/plan.model.mjs";
-//#region src/plan/use.d.ts
 /**
  * Create an asynchronous step from a callback
  *
@@ -32,5 +31,4 @@ export declare function use<Value>(callback: () => Value & StepValue<Value>): St
 export declare function use<Value>(value: Value & StepValue<Value>): Step<Value>;
 export declare namespace use {
   export var async: typeof asyncUse;
-}
-//#endregion
+}

package/dist/plan/use.mjs

@@ -1,9 +1,9 @@
+import { getGenerator } from "../internal/plan/index.mjs";
 import { isError, isOk } from "../internal/result/misc.mjs";
 import { PLAN_MESSAGE_USE_NESTED_FN, PLAN_MESSAGE_USE_SYNC_ASYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
-import { getGenerator } from "../internal/plan/index.mjs";
 import { isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncPlan, isAsyncStep, isAsyncSuccess, isGenerator } from "./is.mjs";
 import { fail } from "./misc.mjs";
-//#region src/plan/use.ts
+// src/plan/use.ts
 function AsyncStep(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
@@ -19,7 +19,10 @@ function Step(generator) {
 }
 Step.prototype[Symbol.iterator] = getGenerator;
 function asyncUse(value) {
-	return new AsyncStep(async function* () {
+	return new AsyncStep(getAsyncUseStep(value));
+}
+function getAsyncUseStep(value) {
+	return async function* () {
 		let actual = value;
 		if (typeof actual === "function") actual = actual();
 		actual = await actual;
@@ -36,11 +39,10 @@ function asyncUse(value) {
 			return;
 		}
 		return actual;
-	});
+	};
 }
-function use(value) {
-	validateUseInput(value, false);
-	return new Step(function* () {
+function getUseStep(value) {
+	return function* () {
 		let actual = value;
 		if (typeof actual === "function") {
 			actual = actual();
@@ -58,12 +60,15 @@ function use(value) {
 			return;
 		}
 		return actual;
-	});
+	};
+}
+function use(value) {
+	validateUseInput(value, false);
+	return new Step(getUseStep(value));
 }
 function validateUseInput(value, resolved) {
 	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error(PLAN_MESSAGE_USE_SYNC_ASYNC);
 	if (resolved && typeof value === "function") throw new Error(PLAN_MESSAGE_USE_NESTED_FN);
 }
 use.async = asyncUse;
-//#endregion
 export { asyncUse, use };

package/dist/promise/delay.d.mts

@@ -1,5 +1,4 @@
 import { PromiseOptions } from "../models/promise.model.mjs";
-//#region src/promise/delay.d.ts
 /**
  * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted
  *
@@ -13,5 +12,4 @@ export declare function delay(options?: PromiseOptions): Promise<void>;
  * @param time How long to wait for _(in milliseconds; defaults to `0`)_
  * @returns Delayed promise
  */
-export declare function delay(time?: number): Promise<void>;
-//#endregion
+export declare function delay(time?: number): Promise<void>;

package/dist/promise/delay.mjs

@@ -1,9 +1,9 @@
 import { createAborter } from "../internal/aborter.mjs";
-import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
 import { getLimiter } from "../internal/function/limit.mjs";
+import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
-//#region src/promise/delay.ts
+// src/promise/delay.ts
 function delay(options) {
 	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
@@ -21,5 +21,4 @@ function delay(options) {
 		else limiter.run();
 	});
 }
-//#endregion
 export { delay };

package/dist/promise/helpers.d.mts

@@ -1,6 +1,5 @@
 import { RequiredKeys } from "../models/index.mjs";
 import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "../models/promise.model.mjs";
-//#region src/promise/helpers.d.ts
 export declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, "time">;
 export declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, "strategy">;
 export declare function getResultsFromPromises(promised: Array<PromisesValue<unknown>> | Record<string, PromisesValue<unknown>>): unknown;
@@ -18,5 +17,4 @@ export declare function isFulfilled<Value>(value: unknown): value is FulfilledPr
  * @param value Value to check
  * @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
  */
-export declare function isRejected(value: unknown): value is RejectedPromise;
-//#endregion
+export declare function isRejected(value: unknown): value is RejectedPromise;

package/dist/promise/helpers.mjs

@@ -1,8 +1,8 @@
+import { getNumberOrDefault } from "../internal/defaults.mjs";
 import { isPlainObject } from "../internal/is.mjs";
 import { error, ok } from "../internal/result/misc.mjs";
-import { getNumberOrDefault } from "../internal/defaults.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "../models/promise.model.mjs";
-//#region src/promise/helpers.ts
+// src/promise/helpers.ts
 function createPromiseOptions(input) {
 	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
 	if (input instanceof AbortSignal) return {
@@ -62,5 +62,4 @@ function isPromiseResult(value, type) {
 function isRejected(value) {
 	return isPromiseResult(value, PROMISE_TYPE_REJECTED);
 }
-//#endregion
 export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.d.mts

@@ -1,6 +1,5 @@
 import { PlainObject } from "../models/index.mjs";
 import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "../models/promise.model.mjs";
-//#region src/promise/index.d.ts
 type AttemptPromiseOptions = PromiseOptions | AbortSignal | number;
 /**
  * Wrap a _Promise_ with safety handlers
@@ -107,5 +106,4 @@ export declare function resultPromises<Items extends PlainObject>(items: Items,
 export declare namespace promises {
   export var result: typeof resultPromises;
 }
-//#endregion
 export {};

package/dist/promise/index.mjs

@@ -1,11 +1,11 @@
-import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { createAborter } from "../internal/aborter.mjs";
+import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { asyncAttempt } from "../internal/result/attempt.mjs";
 import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "../models/promise.model.mjs";
 import { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";
-//#region src/promise/index.ts
+// src/promise/index.ts
 async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
 	if (!isFunction && !(value instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT);
@@ -15,13 +15,13 @@ async function attemptPromise(value, options) {
 		rejector(signal?.reason);
 	});
 	async function handler(resolve, reject) {
-		const result = await asyncAttempt(async () => {
+		const attempted = await asyncAttempt(async () => {
 			let result = isFunction ? value() : await value;
 			if (result instanceof Promise) result = await result;
 			return result;
 		});
-		if (result.ok) settlePromise(resolve, result.value, aborter);
-		else settlePromise(reject, result.error, aborter);
+		if (attempted.ok) settlePromise(resolve, attempted.value, aborter);
+		else settlePromise(reject, attempted.error, aborter);
 	}
 	let rejector;
 	const promise = new Promise((resolve, reject) => {
@@ -75,5 +75,4 @@ async function resultPromises(items, signal) {
 	return promises(items, signal).then(getResultsFromPromises);
 }
 promises.result = resultPromises;
-//#endregion
 export { attemptPromise, promises, resultPromises };

package/dist/promise/misc.d.mts

@@ -1,9 +1,8 @@
 import { Aborter } from "../models/aborter.model.mjs";
-import { Result } from "../models/result.model.mjs";
 import { CancelablePromise, PromiseParameters } from "../models/promise.model.mjs";
+import { Result } from "../models/result.model.mjs";
 import { toPromise } from "../result/misc.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
-//#region src/promise/misc.d.ts
 /**
  * Create a cancelable _Promise_
  *
@@ -33,5 +32,4 @@ export declare function toResult<Value>(callback: () => Promise<Value>): Promise
  * @returns Promised result
  */
 export declare function toResult<Value>(promise: Promise<Value>): Promise<Result<Value>>;
-//#endregion
 export { toPromise as fromResult, isFulfilled, isRejected };

package/dist/promise/misc.mjs

@@ -1,8 +1,8 @@
 import { error, ok } from "../internal/result/misc.mjs";
-import { toPromise } from "../result/misc.mjs";
 import { CancelablePromise, PROMISE_MESSAGE_EXPECTATION_RESULT } from "../models/promise.model.mjs";
+import { toPromise } from "../result/misc.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
-//#region src/promise/misc.ts
+// src/promise/misc.ts
 /**
 * Create a cancelable _Promise_
 *
@@ -50,5 +50,4 @@ async function toResult(value) {
 	if (!(actual instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT);
 	return actual.then((result) => ok(result)).catch((reason) => error(reason));
 }
-//#endregion
 export { cancelable, toPromise as fromResult, handleResult, isFulfilled, isRejected, settlePromise, toResult };

package/dist/promise/models.d.mts

@@ -1,2 +1,2 @@
-import { CancelablePromise, FulfilledPromise, PromiseOptions, PromiseStrategy, PromiseTimeoutError, PromisesOptions, RejectedPromise } from "../models/promise.model.mjs";
-export { CancelablePromise, type FulfilledPromise, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type RejectedPromise };
+import { CancelablePromise, FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, RejectedPromise, TimedError } from "../models/promise.model.mjs";
+export { CancelablePromise, type FulfilledPromise, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type RejectedPromise, TimedError };

package/dist/promise/models.mjs

@@ -1 +1 @@
-export { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";
+export { CancelablePromise, TimedError } from "../models/promise.model.mjs";

package/dist/promise/timed.d.mts

@@ -1,6 +1,5 @@
 import { RequiredKeys } from "../models/index.mjs";
 import { PromiseOptions } from "../models/promise.model.mjs";
-//#region src/promise/timed.d.ts
 /**
  * @internal
  */
@@ -20,5 +19,4 @@ export declare function timed<Value>(promise: Promise<Value>, options: RequiredK
  * @param time How long to wait for _(in milliseconds; defaults to `0`)_
  * @returns Timed _Promise_
  */
-export declare function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;
-//#endregion
+export declare function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;

package/dist/promise/timed.mjs

@@ -1,10 +1,10 @@
 import { createAborter } from "../internal/aborter.mjs";
-import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
 import { getLimiter } from "../internal/function/limit.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "../models/promise.model.mjs";
+import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_TIMED, TimedError } from "../models/promise.model.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
-//#region src/promise/timed.ts
+// src/promise/timed.ts
 /**
 * @internal
 */
@@ -13,7 +13,7 @@ async function getTimedPromise(promise, time, signal) {
 		limiter.cancel();
 		rejector(signal?.reason);
 	});
-	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
+	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(rejector, new TimedError(), aborter), time);
 	let rejector;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
@@ -31,5 +31,4 @@ async function timed(promise, options) {
 	if (signal?.aborted ?? false) throw signal?.reason;
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
-//#endregion
 export { getTimedPromise, timed };

package/dist/query.d.mts

@@ -1,5 +1,4 @@
 import { PlainObject } from "./models/index.mjs";
-//#region src/query.d.ts
 /**
  * Convert a query string to a plain _(nested)_ object
  *
@@ -13,5 +12,4 @@ export declare function fromQuery(query: string): PlainObject;
  * @param parameters Plain object to convert
  * @returns Query string representation of the object
  */
-export declare function toQuery(parameters: PlainObject): string;
-//#endregion
+export declare function toQuery(parameters: PlainObject): string;

package/dist/query.mjs

@@ -1,9 +1,9 @@
 import { isPlainObject } from "./internal/is.mjs";
-import { getString, ignoreKey, join, tryDecode, tryEncode } from "./internal/string/misc.mjs";
 import { getNumber } from "./internal/number.mjs";
+import { getString, ignoreKey, join, tryDecode, tryEncode } from "./internal/string/misc.mjs";
 import { setValue } from "./internal/value/set.mjs";
 import { QUERY_EXPRESSION_ARRAY_SUFFIX, QUERY_EXPRESSION_BOOLEAN, QUERY_TRUE, QUERY_TYPES } from "./models/query.model.mjs";
-//#region src/query.ts
+// src/query.ts
 /**
 * Convert a query string to a plain _(nested)_ object
 *
@@ -73,5 +73,4 @@ function isDecodable(value) {
 function toQuery(parameters) {
 	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), "&") : "";
 }
-//#endregion
 export { fromQuery, toQuery };

package/dist/queue.d.mts

@@ -1,6 +1,5 @@
 import { GenericAsyncCallback, GenericCallback } from "./models/index.mjs";
 import { KeyedQueue, Queue, QueueOptions, Queued } from "./models/queue.model.mjs";
-//#region src/queue.d.ts
 declare function KeyedQueue(this: any, callback: GenericAsyncCallback, options: Required<QueueOptions>): void;
 declare function Queue(this: any, callback: GenericAsyncCallback, options: Required<QueueOptions>, key?: string): void;
 /**
@@ -54,5 +53,4 @@ export declare function queue<Callback extends GenericCallback>(callback: Callba
 export declare namespace queue {
   export var keyed: typeof keyedQueue;
 }
-//#endregion
 export type { KeyedQueue, Queue, QueueOptions, Queued };

package/dist/queue.mjs

@@ -1,17 +1,17 @@
 import { createAborter } from "./internal/aborter.mjs";
+import { getBooleanOrDefault, getNumberOrDefault } from "./internal/defaults.mjs";
 import { min } from "./internal/math/aggregate.mjs";
 import { asyncAttempt } from "./internal/result/attempt.mjs";
-import { getBooleanOrDefault, getNumberOrDefault } from "./internal/defaults.mjs";
-import { QUEUE_HANDLE_CLEAR, QUEUE_HANDLE_PAUSE, QUEUE_HANDLE_RESUME, QUEUE_MESSAGE_CALLBACK, QUEUE_MESSAGE_CLEAR, QUEUE_MESSAGE_KEY, QUEUE_MESSAGE_MAXIMUM, QUEUE_MESSAGE_REMOVE, QUEUE_NAME_KEYED, QUEUE_NAME_QUEUE, QUEUE_PROPERTY, QUEUE_STATUS_ACTIVE, QUEUE_STATUS_EMPTY, QUEUE_STATUS_FULL, QUEUE_STATUS_PAUSED, QUEUE_SYMBOL, QueueError } from "./models/queue.model.mjs";
-//#region src/queue.ts
+import { QUEUE_HANDLE_CLEAR, QUEUE_HANDLE_PAUSE, QUEUE_HANDLE_RESUME, QUEUE_MESSAGE_CALLBACK, QUEUE_MESSAGE_CLEAR, QUEUE_MESSAGE_KEY, QUEUE_MESSAGE_MAXIMUM, QUEUE_MESSAGE_REMOVE, QUEUE_NAME_KEYED, QUEUE_NAME_QUEUE, QUEUE_STATUS_ACTIVE, QUEUE_STATUS_EMPTY, QUEUE_STATUS_FULL, QUEUE_STATUS_PAUSED, QUEUE_SYMBOL, QueueError } from "./models/queue.model.mjs";
+// src/queue.ts
 function KeyedQueue(callback, options) {
 	this[QUEUE_SYMBOL] = {
 		callback,
 		options: createQueueOptions(options),
-		queues: /* @__PURE__ */ new Map()
+		queues: /* @__PURE__ */ new Map(),
+		type: QUEUE_NAME_KEYED
 	};
 }
-KeyedQueue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_KEYED;
 KeyedQueue.prototype.add = addKeyedQueue;
 KeyedQueue.prototype.clear = clearQueues;
 KeyedQueue.prototype.get = getQueue;
@@ -69,10 +69,10 @@ function Queue(callback, options, key) {
 		id: 0,
 		items: [],
 		paused: !options.autostart,
-		runners: 0
+		runners: 0,
+		type: QUEUE_NAME_QUEUE
 	};
 }
-Queue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_QUEUE;
 Queue.prototype.add = addToQueue;
 Queue.prototype.clear = clearQueue;
 Queue.prototype.pause = pauseQueue;
@@ -229,9 +229,9 @@ function getQueueSize() {
 }
 function getStatus(state, status) {
 	const queues = state.queues.entries();
-	const result = [];
-	for (const [key, queue] of queues) if (queue[status]) result.push(key);
-	return result;
+	const queued = [];
+	for (const [key, queue] of queues) if (queue[status]) queued.push(key);
+	return queued;
 }
 function handleQueuedResult(item, error, result) {
 	item.aborter?.cancel();
@@ -276,7 +276,7 @@ function isQueue(value) {
 	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && "$queue" in value && value["$queue"] === name;
+	return typeof value === "object" && value != null && QUEUE_SYMBOL in value && value[QUEUE_SYMBOL].type === name;
 }
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
@@ -359,5 +359,4 @@ async function run(state) {
 	state.runners -= 1;
 }
 queue.keyed = keyedQueue;
-//#endregion
 export { isKeyedQueue, isQueue, keyedQueue, queue };

package/dist/random.d.mts

@@ -1,5 +1,4 @@
 import { getRandom, getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
-//#region src/random.d.ts
 /**
  * Get a random boolean
  *
@@ -49,5 +48,4 @@ export declare function getRandomItems<Value>(array: Value[], amount: number): V
  * @returns Shuffled version of the original array
  */
 export declare function getRandomItems<Value>(array: Value[]): Value[];
-//#endregion
 export { getRandom, getRandomFloatingNumber as getRandomFloat, getRandomInteger };

package/dist/random.mjs

@@ -1,8 +1,8 @@
-import { getRandom, getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
 import { shuffle } from "./internal/array/shuffle.mjs";
+import { getRandom, getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs";
 import { join } from "./internal/string/misc.mjs";
 import { RANDOM_ALPHABET, RANDOM_BOOLEAN_MODIFIER, RANDOM_HEX_CHARACTERS } from "./models/random.model.mjs";
-//#region src/random.ts
+// src/random.ts
 /**
 * Get a random boolean
 *
@@ -58,5 +58,4 @@ function getRandomItems(array, amount) {
 	if (amount === 1) return [array[getRandomInteger(0, array.length - 1)]];
 	return typeof amount !== "number" || amount <= 0 || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
 }
-//#endregion
 export { getRandom, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems };

package/dist/result/match.d.mts

@@ -1,5 +1,4 @@
 import { AnyResult, ResultMatch } from "../models/result.model.mjs";
-//#region src/result/match.d.ts
 /**
  * Handles a _Result_ with match callbacks
  *
@@ -40,5 +39,4 @@ export declare function matchResult<Value, Returned, E = Error>(result: AnyResul
 export declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>["ok"], error: ResultMatch<Value, Returned, E>["error"]): Returned;
 export declare namespace matchResult {
   export var async: typeof asyncMatchResult;
-}
-//#endregion
+}

package/dist/result/match.mjs

@@ -1,6 +1,6 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { isOk, isResult } from "../internal/result/misc.mjs";
-//#region src/result/match.ts
+// src/result/match.ts
 async function asyncMatchResult(result, first, second) {
 	let value;
 	if (typeof result === "function") value = await result();
@@ -35,5 +35,4 @@ const MATCH_MESSAGE_ERROR = "`result.match` expected an Error callback";
 const MATCH_MESSAGE_OK = "`result.match` expected an Ok callback";
 const MATCH_MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
 matchResult.async = asyncMatchResult;
-//#endregion
 export { asyncMatchResult, matchResult };

package/dist/result/misc.d.mts

@@ -1,6 +1,5 @@
 import { AnyResult } from "../models/result.model.mjs";
 import { error, isError, isOk, isResult, ok, unwrap } from "../internal/result/misc.mjs";
-//#region src/result/misc.d.ts
 /**
  * Converts a result to a _Promise_
  *
@@ -19,5 +18,4 @@ export declare function toPromise<Value, E = Error>(callback: () => AnyResult<Va
  * @returns Promised result
  */
 export declare function toPromise<Value, E = Error>(result: AnyResult<Value, E>): Promise<Value>;
-//#endregion
 export { error, isError, isOk, isResult, ok, unwrap };

package/dist/result/misc.mjs

@@ -1,5 +1,5 @@
 import { error, isError, isOk, isResult, ok, unwrap } from "../internal/result/misc.mjs";
-//#region src/result/misc.ts
+// src/result/misc.ts
 async function toPromise(result) {
 	const actual = typeof result === "function" ? result() : result;
 	if (!isResult(actual)) throw new TypeError(RESULT_MESSAGE_PROMISE);
@@ -7,5 +7,4 @@ async function toPromise(result) {
 	throw actual.error;
 }
 const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
-//#endregion
 export { error, isError, isOk, isResult, ok, toPromise, unwrap };

package/dist/result/work/flow.d.mts

@@ -1,6 +1,5 @@
 import { GenericCallback } from "../../models/index.mjs";
 import { AttemptAsyncFlow, AttemptFlow, Result, UnwrapValue } from "../../models/result.model.mjs";
-//#region src/result/work/flow.d.ts
 /**
  * Create an asynchronous _Flow_, a function that attempts to pipe a value through a series of functions
  *
@@ -171,5 +170,4 @@ export declare function attemptFlow<First extends GenericCallback>(first: First,
 export declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
 export declare namespace attemptFlow {
   export var async: typeof attemptAsyncFlow;
-}
-//#endregion
+}

package/dist/result/work/flow.mjs

@@ -1,27 +1,20 @@
-import { isError, isOk } from "../../internal/result/misc.mjs";
-import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
+import { unwrapWork } from "../../internal/function/misc.mjs";
 import { asyncFlow, flow } from "../../internal/function/work.mjs";
-//#region src/result/work/flow.ts
+import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
+// src/result/work/flow.ts
 function attemptAsyncFlow(...fns) {
 	let Flow;
 	return (...args) => asyncAttempt(() => {
 		Flow ??= asyncFlow(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
+		return Flow(...args.map(unwrapWork));
 	});
 }
 function attemptFlow(...fns) {
 	let Flow;
 	return (...args) => attempt(() => {
 		Flow ??= flow(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
+		return Flow(...args.map(unwrapWork));
 	});
 }
 attemptFlow.async = attemptAsyncFlow;
-//#endregion
 export { attemptAsyncFlow, attemptFlow };

package/dist/result/work/pipe.d.mts

@@ -1,6 +1,5 @@
 import { GenericCallback } from "../../models/index.mjs";
 import { Result, UnwrapValue } from "../../models/result.model.mjs";
-//#region src/result/work/pipe.d.ts
 type InitialAsyncPipeValue<Initial> = GenericCallback | Initial | Promise<Initial> | Result<Initial>;
 type InitialPipeValue<Initial> = GenericCallback | Initial | Result<Initial>;
 type WrapValue<Value> = Result<UnwrapValue<Value>>;
@@ -183,5 +182,4 @@ export declare function attemptPipe<Initial>(initial: InitialPipeValue<Initial>,
 export declare namespace attemptPipe {
   export var async: typeof attemptAsyncPipe;
 }
-//#endregion
 export {};

package/dist/result/work/pipe.mjs

@@ -1,7 +1,7 @@
+import { asyncPipe, pipe } from "../../internal/function/work.mjs";
 import { isError, isOk } from "../../internal/result/misc.mjs";
 import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
-import { asyncPipe, pipe } from "../../internal/function/work.mjs";
-//#region src/result/work/pipe.ts
+// src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
 	return asyncAttempt(async () => {
 		if (isError(initial)) throw initial.error;
@@ -23,5 +23,4 @@ function attemptPipe(initial, first, ...seconds) {
 	});
 }
 attemptPipe.async = attemptAsyncPipe;
-//#endregion
 export { attemptAsyncPipe, attemptPipe };