@oscarpalmer/atoms 0.213.0 → 0.214.0

package/dist/{color/models.d.mts → models/color.model.d.mts}

@@ -1,7 +1,7 @@
-import { Subscription } from "../internal/subscription.mjs";
-import { Herald, HeraldEvents } from "../internal/models/herald.model.mjs";
-import { COLOR_SYMBOL } from "./constants.mjs";
-//#region src/color/models.d.ts
+import { Subscription } from "./subscription.model.mjs";
+import { Herald, HeraldEvents } from "./herald.model.mjs";
+import { COLOR_SYMBOL } from "../color/constants.mjs";
+//#region src/models/color.model.d.ts
 export type Alpha = {
   hex: string;
   value: number;

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

@@ -0,0 +1,13 @@
+import { NestedKeys, PlainObject } from "../index.mjs";
+//#region src/models/function/assert.model.d.ts
+export type AssertNestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: AssertNestedPick<Value[Key], Rest>; } : never : Path extends keyof Value ? { [Key in Path]: Value[Key]; } : never : never;
+/**
+ * Asserter for a property of a value
+ */
+export type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends AssertNestedPick<Value, Path> = AssertNestedPick<Value, Path>> = Asserter<Asserted>;
+/**
+ * A function that asserts a value is of a specific type, throwing an error if it is not
+ */
+export type Asserter<Value> = (value: unknown) => asserts value is Value;
+export declare const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
+//#endregion

package/dist/models/function/assert.model.mjs

@@ -0,0 +1,4 @@
+//#region src/models/function/assert.model.ts
+const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
+//#endregion
+export { ASSERT_MESSAGE_VALUE_DEFINED };

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

@@ -0,0 +1,71 @@
+import { GenericAsyncCallback, GenericCallback } from "../index.mjs";
+//#region src/models/function/limiter.model.d.ts
+export type AsyncLimiterItem = {
+  parameters: unknown[];
+  promise: Promise<unknown>;
+  reject(reason?: unknown): void;
+  resolve(value?: unknown): void;
+  running: boolean;
+};
+/**
+ * An asynchronous function that can be cancelled
+ */
+export type AsyncLimiter<Callback extends GenericAsyncCallback> = {
+  /**
+   * Cancel the function
+   */
+  cancel(): void;
+  /**
+   * Call the function
+   *
+   * @param parameters Function parameters
+   * @returns Function result
+   */
+  run(...parameters: Parameters<Callback>): Promise<ReturnType<Callback>>;
+};
+export type AsyncLimiterState = {
+  last?: AsyncLimiterItem;
+} & LimiterState<GenericAsyncCallback>;
+export type InternalAsyncLimiter = {
+  [LIMITER_SYMBOL]: AsyncLimiterState;
+} & AsyncLimiter<GenericAsyncCallback>;
+export type InternalLimiter = {
+  [LIMITER_SYMBOL]: LimiterState;
+} & Limiter<GenericCallback>;
+/**
+ * A function that can be cancelled
+ */
+export type Limiter<Callback extends GenericCallback> = {
+  /**
+   * Cancel the function
+   */
+  cancel(): void;
+  /**
+   * Call the function
+   *
+   * @param parameters Function parameters
+   * @returns Function result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+};
+export type LimiterState<Callback = GenericCallback> = {
+  callback: Callback;
+  interval: number;
+  parameters: unknown[];
+  start?: number;
+  throttle: boolean;
+  timer?: number;
+  type: LimiterType;
+};
+export type LimiterType = "debounce" | "throttle" | "wait";
+export declare const LIMITER_DEBOUNCE: LimiterType;
+export declare const LIMITER_NAME_ASYNC = "asyncLimiter";
+export declare const LIMITER_NAME_SYNC = "limiter";
+export declare const LIMITER_PROPERTY = "$limiter";
+export declare const LIMITER_OFFSET = 5;
+export declare const LIMITER_SYMBOL: unique symbol;
+export declare const LIMITER_THROTTLE: LimiterType;
+export declare const LIMITER_WAIT: LimiterType;
+export declare const clearTimer: (handle: number) => void;
+export declare const startTimer: (callback: FrameRequestCallback) => number;
+//#endregion

package/dist/models/function/limiter.model.mjs

@@ -0,0 +1,15 @@
+//#region src/models/function/limiter.model.ts
+const LIMITER_DEBOUNCE = "debounce";
+const LIMITER_NAME_ASYNC = "asyncLimiter";
+const LIMITER_NAME_SYNC = "limiter";
+const LIMITER_PROPERTY = "$limiter";
+const LIMITER_OFFSET = 5;
+const LIMITER_SYMBOL = Symbol("limiter");
+const LIMITER_THROTTLE = "throttle";
+const LIMITER_WAIT = "wait";
+// istanbul ignore next
+const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
+// istanbul ignore next
+const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
+//#endregion
+export { LIMITER_DEBOUNCE, LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_OFFSET, LIMITER_PROPERTY, LIMITER_SYMBOL, LIMITER_THROTTLE, LIMITER_WAIT, clearTimer, startTimer };

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

@@ -0,0 +1,88 @@
+import { GenericCallback } from "../index.mjs";
+import { SizedMap } from "../../internal/sized/map.mjs";
+//#region src/models/function/memoize.model.d.ts
+export type InternalMemoized = {
+  [MEMOIZED_SYMBOL]: MemoizedState;
+} & Memoized<GenericCallback>;
+/**
+ * A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
+ */
+export type Memoized<Callback extends GenericCallback> = {
+  /**
+   * Maximum cache size
+   *
+   * @returns Maximum cache size _(or `Number.NaN` if the instance has been destroyed)_
+   */
+  get maximum(): number;
+  /**
+   * Current cache size
+   *
+   * @returns Current cache size _(or `Number.NaN` if the instance has been destroyed)_
+   */
+  get size(): number;
+  /**
+   * Clear the cache
+   */
+  clear(): void;
+  /**
+   * Delete a result from the cache
+   *
+   * @param key Key to delete
+   * @returns `true` if the key existed and was removed, otherwise `false`
+   */
+  delete(key: unknown): boolean;
+  /**
+   * Destroy the instance
+   *
+   * _(When a Memoized instance is destroyed, its cache and callback are removed, and calls to `run` will throw an error)_
+   */
+  destroy(): void;
+  /**
+   * Get a result from the cache
+   *
+   * @param key Key to get
+   * @returns Cached result or `undefined` if it does not exist
+   */
+  get(key: unknown): ReturnType<Callback> | undefined;
+  /**
+   * Does the result exist?
+   *
+   * @param key Key to check
+   * @returns `true` if the result exists, otherwise `false`
+   */
+  has(key: unknown): boolean;
+  /**
+   * Run the callback with the provided parameters
+   *
+   * @param parameters Parameters to pass to the callback
+   * @returns Cached or computed _(then cached)_ result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+};
+/**
+ * Options for a _Memoized_ function
+ */
+export type MemoizedOptions<Callback extends GenericCallback> = {
+  /**
+   * Callback for getting a cache key for the provided parameters
+   */
+  cacheKey?: (...parameters: Parameters<Callback>) => unknown;
+  /**
+   * Size of the cache
+   */
+  cacheSize?: number;
+};
+export type MemoizedState = {
+  cache: SizedMap<unknown, unknown>;
+  getter: GenericCallback;
+  options: MemoizedStateOptions;
+};
+export type MemoizedStateOptions = {
+  cacheKey?: GenericCallback;
+  cacheSize: number;
+};
+export declare const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
+export declare const MEMOIZED_CALLBACK = "Memoized requires a callback function";
+export declare const MEMOIZED_KEY_SEPARATOR = "_";
+export declare const MEMOIZED_SYMBOL: unique symbol;
+//#endregion

package/dist/models/function/memoize.model.mjs

@@ -0,0 +1,7 @@
+//#region src/models/function/memoize.model.ts
+const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
+const MEMOIZED_CALLBACK = "Memoized requires a callback function";
+const MEMOIZED_KEY_SEPARATOR = "_";
+const MEMOIZED_SYMBOL = Symbol("memoized");
+//#endregion
+export { MEMOIZED_CACHE_SIZE_DEFAULT, MEMOIZED_CALLBACK, MEMOIZED_KEY_SEPARATOR, MEMOIZED_SYMBOL };

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

@@ -0,0 +1,76 @@
+import { GenericAsyncCallback, GenericCallback } from "../index.mjs";
+//#region src/models/function/once.model.d.ts
+/**
+ * An asynchronous function that can only be called once, returning the same value on subsequent calls
+ */
+export type AsyncOnce<Callback extends GenericAsyncCallback> = {
+  /**
+   * Did the callback's promise reject?
+   */
+  readonly error: boolean;
+  /**
+   * Has the callback finished?
+   */
+  readonly finished: boolean;
+  /**
+   * Run the callback
+   *
+   * @param parameters Callback parameters
+   * @returns Call result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+} & OnceProperties;
+export type AsyncOnceItem<Value> = {
+  reject(reason?: unknown): void;
+  resolve(value: Value): void;
+};
+export type AsyncOnceState<Value> = {
+  error: boolean;
+  finished: boolean;
+  items: Array<AsyncOnceItem<Value>>;
+} & OnceState<Value, GenericAsyncCallback>;
+export type InternalAsyncOnce = {
+  [ONCE_SYMBOL]: AsyncOnceState<unknown>;
+} & AsyncOnce<GenericAsyncCallback>;
+export type InternalOnce = {
+  [ONCE_SYMBOL]: OnceState<unknown>;
+} & Once<GenericCallback>;
+/**
+ * A callback function that can only be called once, returning the same value on subsequent calls
+ */
+export type Once<Callback extends GenericCallback> = {
+  /**
+   * Run the callback
+   *
+   * @param parameters Callback parameters
+   * @returns Call result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+} & OnceProperties;
+type OnceProperties = {
+  /**
+   * Has the callback been called?
+   */
+  readonly called: boolean;
+  /**
+   * Has the callback's value been cleared?
+   */
+  readonly cleared: boolean;
+  /**
+   * Clear the callback's cached value
+   */
+  clear(): void;
+};
+export type OnceState<Value, Callback = GenericCallback> = {
+  callback: Callback;
+  called: boolean;
+  cleared: boolean;
+  value: Value;
+};
+export declare const ONCE_NAME_ASYNC = "asyncOnce";
+export declare const ONCE_NAME_SYNC = "once";
+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

package/dist/models/function/once.model.mjs

@@ -0,0 +1,9 @@
+//#region src/models/function/once.model.ts
+const ONCE_NAME_ASYNC = "asyncOnce";
+const ONCE_NAME_SYNC = "once";
+const ONCE_PROPERTY = "$once";
+const ONCE_MESSAGE_CLEARED = "Once has been cleared";
+const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+const ONCE_SYMBOL = Symbol(ONCE_PROPERTY);
+//#endregion
+export { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_PROPERTY, ONCE_SYMBOL };

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

@@ -0,0 +1,17 @@
+//#region src/models/function/retry.model.d.ts
+/**
+ * An error thrown when a retry fails
+ */
+export declare class RetryError extends Error {
+  readonly original: unknown;
+  constructor(message: string, original: unknown);
+}
+export type RetryOptions = {
+  delay?: number;
+  times?: number;
+  when?: (error: unknown) => boolean;
+};
+export declare const RETRY_ERROR_NAME = "RetryError";
+export declare const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
+export declare const RETRY_MESSAGE_FAILED = "Retry failed";
+//#endregion

package/dist/models/function/retry.model.mjs

@@ -0,0 +1,17 @@
+//#region src/models/function/retry.model.ts
+/**
+* An error thrown when a retry fails
+*/
+var RetryError = class extends Error {
+	original;
+	constructor(message, original) {
+		super(message);
+		this.original = original;
+		this.name = RETRY_ERROR_NAME;
+	}
+};
+const RETRY_ERROR_NAME = "RetryError";
+const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
+const RETRY_MESSAGE_FAILED = "Retry failed";
+//#endregion
+export { RETRY_ERROR_NAME, RETRY_MESSAGE_EXPECTATION, RETRY_MESSAGE_FAILED, RetryError };

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

@@ -0,0 +1,20 @@
+import { GenericCallback } from "../index.mjs";
+import { Asserter } from "./assert.model.mjs";
+import { UnwrapValue } from "../result.model.mjs";
+//#region src/models/function/work.model.d.ts
+/**
+ * An asynchronous _Flow_, a function that pipes a value through a series of functions
+ */
+export type AsyncFlow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<UnwrapValue<Value>>;
+/**
+ * A synchronous _Flow_, a function that pipe a value through a series of functions
+ */
+export type Flow<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => UnwrapValue<Value>;
+export declare const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
+export declare const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
+export declare const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
+export declare const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
+export declare const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
+export declare const assertFlowFunctions: Asserter<Function[]>;
+export declare const assertPipeFunctions: Asserter<Function[]>;
+//#endregion

package/dist/models/function/work.model.mjs

@@ -0,0 +1,11 @@
+import { assert } from "../../internal/function/assert.mjs";
+//#region src/models/function/work.model.ts
+const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
+const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
+const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
+const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
+const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
+const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_FLOW_ARRAY, TypeError);
+const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
+//#endregion
+export { WORK_MESSAGE_FLOW_ARRAY, WORK_MESSAGE_FLOW_PROMISE, WORK_MESSAGE_NESTING, WORK_MESSAGE_PIPE_ARRAY, WORK_MESSAGE_PIPE_PROMISE, assertFlowFunctions, assertPipeFunctions };

package/dist/{internal/models → models}/herald.model.d.mts

@@ -1,6 +1,6 @@
-import { GenericCallback } from "../../models.mjs";
-import { Subscription, SubscriptionProperty, Subscriptions } from "../subscription.mjs";
-//#region src/internal/models/herald.model.d.ts
+import { GenericCallback } from "./index.mjs";
+import { Subscription, SubscriptionProperty, Subscriptions } from "./subscription.model.mjs";
+//#region src/models/herald.model.d.ts
 export type Herald<Events extends Record<string, GenericCallback>> = {
   readonly events: HeraldEvents<Events>;
   /**

package/dist/{internal/models → models}/herald.model.mjs

@@ -1,5 +1,5 @@
-import { SUBSCRIPTION_NAME } from "../subscription.mjs";
-//#region src/internal/models/herald.model.ts
+import { SUBSCRIPTION_NAME } from "./subscription.model.mjs";
+//#region src/models/herald.model.ts
 const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
 const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for subscription creation`;
 const HERALD_MESSAGE_PROPERTY = `Herald requires valid property information for subscription identification`;

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

@@ -1,4 +1,4 @@
-//#region src/models.d.ts
+//#region src/models/index.d.ts
 /**
  * A generic array or object
  */
@@ -13,6 +13,10 @@ export type BuiltIns = void | Date | Primitive | RegExp;
  * A generic class constructor
  */
 export type Constructor<Instance = unknown> = new (...args: any[]) => Instance;
+/**
+ * A frozen value with readonly properties _(going as deep as possible)_
+ */
+export type Frozen<Value> = Value extends unknown[] ? Readonly<Value> : Value extends PlainObject ? { readonly [Key in keyof Value]: Frozen<Value[Key]>; } : Value extends Map<infer Key, infer Value> ? ReadonlyMap<Key, Frozen<Value>> : Value extends Set<infer Item> ? ReadonlySet<Frozen<Item>> : Readonly<Value>;
 /**
  * A generic async callback function
  */
@@ -72,52 +76,6 @@ export type NumericalKeys<Value> = { [ItemKey in keyof Value]: ItemKey extends n
  * The numerical values of an object
  */
 export type NumericalValues<Item extends PlainObject> = Simplify<{ [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey]; }>;
-/**
- * An asynchronous function that can only be called once, returning the same value on subsequent calls
- */
-export type OnceAsync<Callback extends GenericAsyncCallback> = {
-  /**
-   * Did the callback's promise reject?
-   */
-  readonly error: boolean;
-  /**
-   * Has the callback finished?
-   */
-  readonly finished: boolean;
-  /**
-   * Run the callback
-   *
-   * @param parameters Callback parameters
-   * @returns Call result
-   */
-  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
-} & OnceProperties;
-/**
- * A callback function that can only be called once, returning the same value on subsequent calls
- */
-export type Once<Callback extends GenericCallback> = {
-  /**
-   * Run the callback
-   *
-   * @param parameters Callback parameters
-   * @returns Call result
-   */
-  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
-} & OnceProperties;
-type OnceProperties = {
-  /**
-   * Has the callback been called?
-   */
-  readonly called: boolean;
-  /**
-   * Has the callback's value been cleared?
-   */
-  readonly cleared: boolean;
-  /**
-   * Clear the callback's cached value
-   */
-  clear(): void;
-};
 /**
  * A generic object
  */

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

@@ -0,0 +1,83 @@
+//#region src/models/logger.model.d.ts
+export type InternalTimeLogger = {
+  [LOGGER_SYMBOL]: TimeLoggerState;
+} & TimeLogger;
+export type Lumberjack = {
+  /**
+   * Log any number of values at the "debug" log level
+   */
+  get debug(): typeof console.debug;
+  /**
+   * Log the value and shows all its properties
+   */
+  get dir(): typeof console.dir;
+  /**
+   * Is logging to the console enabled? _(defaults to `true`)_
+   */
+  get enabled(): boolean;
+  /**
+   * Enable or disable logging to the console
+   */
+  set enabled(value: boolean);
+  /**
+   * Log any number of values at the "error" log level
+   */
+  get error(): typeof console.error;
+  /**
+   * Log any number of values at the "info" log level
+   */
+  get info(): typeof console.info;
+  /**
+   * Log any number of values at the "log" log level
+   */
+  get log(): typeof console.log;
+  /**
+   * Log data as a table, with optional properties to use as columns
+   */
+  get table(): typeof console.table;
+  /**
+   * Log any number of values together with a trace from where it was called
+   */
+  get trace(): typeof console.trace;
+  /**
+   * Log any number of values at the "warn" log level
+   */
+  get warn(): typeof console.warn;
+  /**
+   * Start a timed logger with a label
+   *
+   * @param label Label for the logger
+   * @returns _TimedLogger_ instance
+   */
+  time(label: string): TimeLogger;
+};
+/**
+ * A named timer that can be used to log durations to the console
+ */
+export type TimeLogger = {
+  /**
+   * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+   */
+  get active(): boolean;
+  /**
+   * Log the current duration of the timer _(ignored if logging is disabled)_
+   */
+  get log(): () => void;
+  /**
+   * Stop the timer and logs the total duration
+   *
+   * _(Will always log the total duration, even if logging is disabled)_
+   */
+  get stop(): () => void;
+};
+export type TimeLoggerState = {
+  isActive(): boolean;
+  label: string;
+  started: boolean;
+  stopped: boolean;
+};
+export declare const LOGGER_NAME = "Logger";
+export declare const LOGGER_NAME_TIMED = "TimedLogger";
+export declare const LOGGER_PROPERTY = "$logger";
+export declare const LOGGER_SYMBOL: unique symbol;
+//#endregion

package/dist/models/logger.model.mjs

@@ -0,0 +1,7 @@
+//#region src/models/logger.model.ts
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
+const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
+//#endregion
+export { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_PROPERTY, LOGGER_SYMBOL };

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

@@ -0,0 +1,16 @@
+//#region src/models/math.model.d.ts
+export type Aggregation = {
+  array: boolean;
+  count: number;
+  first: boolean;
+  items?: Record<number, unknown[]>;
+  value: number;
+};
+export type AggregationCallback = (aggregation: Aggregation, value: number, notNumber: boolean, item?: unknown) => number;
+export type AggregationType = "average" | "max" | "min" | "sum";
+export type NonAverageAggregationType = "max" | "min" | "sum";
+export declare const AGGREGATION_AVERAGE = "average";
+export declare const AGGREGATION_MAX = "max";
+export declare const AGGREGATION_MIN = "min";
+export declare const AGGREGATION_SUM = "sum";
+//#endregion

package/dist/models/math.model.mjs

@@ -0,0 +1,7 @@
+//#region src/models/math.model.ts
+const AGGREGATION_AVERAGE = "average";
+const AGGREGATION_MAX = "max";
+const AGGREGATION_MIN = "min";
+const AGGREGATION_SUM = "sum";
+//#endregion
+export { AGGREGATION_AVERAGE, AGGREGATION_MAX, AGGREGATION_MIN, AGGREGATION_SUM };

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

@@ -0,0 +1,10 @@
+//#region src/models/misc.model.d.ts
+export declare const EXPRESSION_INTEGER: RegExp;
+export declare const EXPRESSION_NUMBER_BINARY: RegExp;
+export declare const EXPRESSION_NUMBER_OCTAL: RegExp;
+export declare const EXPRESSION_NUMBER_ZEROISH: RegExp;
+export declare const EXPRESSION_NUMERICAL_PREFIX: RegExp;
+export declare const EXPRESSION_WHITESPACE_MULTIPLE: RegExp;
+export declare const EXPRESSION_WHITESPACE_ONLY: RegExp;
+export declare const NUMBER_OCTAL_VALUE = 8;
+//#endregion

package/dist/models/misc.model.mjs

@@ -0,0 +1,11 @@
+//#region src/models/misc.model.ts
+const EXPRESSION_INTEGER = /^\d+$/;
+const EXPRESSION_NUMBER_BINARY = /^0b[01]+$/i;
+const EXPRESSION_NUMBER_OCTAL = /^0o[0-7]+$/i;
+const EXPRESSION_NUMBER_ZEROISH = /^\s*0+\s*$/;
+const EXPRESSION_NUMERICAL_PREFIX = /^\d/;
+const EXPRESSION_WHITESPACE_MULTIPLE = /\s+/g;
+const EXPRESSION_WHITESPACE_ONLY = /^\s*$/;
+const NUMBER_OCTAL_VALUE = 8;
+//#endregion
+export { EXPRESSION_INTEGER, EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZEROISH, EXPRESSION_NUMERICAL_PREFIX, EXPRESSION_WHITESPACE_MULTIPLE, EXPRESSION_WHITESPACE_ONLY, NUMBER_OCTAL_VALUE };

package/dist/{internal/models → models}/plan.model.d.mts

@@ -1,5 +1,5 @@
 import { Err, Ok, Result } from "./result.model.mjs";
-//#region src/internal/models/plan.model.d.ts
+//#region src/models/plan.model.d.ts
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
@@ -26,7 +26,7 @@ export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    */
   run(...parameters: Parameters): Promise<PlanReturned<Returned>>;
 };
-type AsyncPlanState = {
+export type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
 } & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
 type BaseState<Type extends PlanType> = {
@@ -69,7 +69,7 @@ type PlanErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<
 export type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrors<Yielded, Returned>;
 type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : never;
 export type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
-type PlanState = {
+export type PlanState = {
   generator(...parameters: unknown[]): Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
 export type PlanType = "asyncPlan" | "plan";

package/dist/{internal/models → models}/plan.model.mjs

@@ -1,4 +1,4 @@
-//#region src/internal/models/plan.model.ts
+//#region src/models/plan.model.ts
 const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
 const GENERATOR_NAME_SYNC = "GeneratorFunction";
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";