@oscarpalmer/atoms 0.204.1 → 0.205.0

package/dist/index.mjs

@@ -115,6 +115,15 @@ function filter(array, ...parameters) {
 }
 filter.remove = exclude;
 //#endregion
+//#region src/array/find.ts
+function find(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, false);
+}
+function findLast(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, true);
+}
+find.last = findLast;
+//#endregion
 //#region src/array/first.ts
 function first(array, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, void 0, false, false);
@@ -122,7 +131,7 @@ function first(array, ...parameters) {
 function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
-first.default = firstOrDefault;
+first.defaulted = firstOrDefault;
 //#endregion
 //#region src/internal/array/group.ts
 function groupValues(array, key, value, arrays) {
@@ -397,15 +406,6 @@ function getArray(value, indiced) {
 	return array;
 }
 //#endregion
-//#region src/internal/array/index-of.ts
-function indexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, false);
-}
-function lastIndexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, true);
-}
-indexOf.last = lastIndexOf;
-//#endregion
 //#region src/internal/array/match.ts
 function endsWithArray(haystack, needle, key) {
 	return endings.has(getPosition(haystack, needle, key)[1]);
@@ -551,15 +551,6 @@ function exists(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, false) > -1;
 }
 //#endregion
-//#region src/array/find.ts
-function find(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, false);
-}
-function findLast(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, true);
-}
-find.last = findLast;
-//#endregion
 //#region src/array/flatten.ts
 /**
 * Flatten an array _(using native `flat` and maximum depth)_
@@ -677,24 +668,6 @@ function reverse(array) {
 	return array;
 }
 //#endregion
-//#region src/array/select.ts
-function reverseSelect(array, ...parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.shift(),
-		reverse: true
-	}).matched;
-}
-function select(array, ...parameters) {
-	return selectValues(array, parameters);
-}
-function selectValues(array, parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.pop(),
-		reverse: false
-	}).matched;
-}
-select.reverse = reverseSelect;
-//#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
 	const { matched } = findValues("all", array, parameters);
@@ -821,7 +794,7 @@ function last(array, ...parameters) {
 function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
-last.default = lastOrDefault;
+last.defaulted = lastOrDefault;
 //#endregion
 //#region src/internal/array/overlap.ts
 function arraysOverlap(first, second) {
@@ -916,6 +889,24 @@ function moveToIndex(array, value, index, key) {
 move.indices = moveIndices;
 move.toIndex = moveToIndex;
 //#endregion
+//#region src/array/select.ts
+function filterAndMap(array, ...parameters) {
+	return selectValues(array, parameters);
+}
+function mapAndFilter(array, ...parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.shift(),
+		reverse: true
+	}).matched;
+}
+function selectValues(array, parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.pop(),
+		reverse: false
+	}).matched;
+}
+filterAndMap.reverse = mapAndFilter;
+//#endregion
 //#region src/internal/math/aggregate.ts
 function aggregate(type, array, key, first) {
 	const length = Array.isArray(array) ? array.length : 0;
@@ -1347,6 +1338,15 @@ sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
 //#endregion
+//#region src/internal/array/index-of.ts
+function indexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
+}
+function lastIndexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, true);
+}
+indexOf.last = lastIndexOf;
+//#endregion
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
 	if (!Array.isArray(array)) return [];
@@ -2064,66 +2064,6 @@ const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
 retry.async = asyncRetry;
 //#endregion
-//#region src/internal/function/work.ts
-function asyncFlow(...fns) {
-	assertFlowFunctions(fns);
-	return (...args) => asyncWork(args.map((value) => {
-		if (isError(value)) throw value.error;
-		return isOk(value) ? value.value : value;
-	}), fns, true);
-}
-function flow(...fns) {
-	assertFlowFunctions(fns);
-	return (...args) => work(args.map((value) => {
-		if (isError(value)) throw value.error;
-		return isOk(value) ? value.value : value;
-	}), fns, true);
-}
-async function asyncPipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return asyncWork(value, pipes, false);
-}
-function pipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return work(value, pipes, false);
-}
-async function asyncWork(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial);
-	for (let index = 0; index < length; index += 1) {
-		const fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
-	}
-	return transformed;
-}
-function unwrapValue(value, flow, nested) {
-	if (typeof value === "function") {
-		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
-		return unwrapValue(value(), flow, true);
-	}
-	if (flow != null && value instanceof Promise) throw new TypeError(flow ? WORK_MESSAGE_FLOW_PROMISE : WORK_MESSAGE_PIPE_PROMISE);
-	if (isError(value)) throw value.error;
-	return isOk(value) ? value.value : value;
-}
-function work(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial, flow);
-	for (let index = 0; index < length; index += 1) {
-		const fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? fn(...initial) : fn(transformed), flow);
-	}
-	return transformed;
-}
-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);
-flow.async = asyncFlow;
-pipe.async = asyncPipe;
-//#endregion
 //#region src/internal/number.ts
 /**
 * Is the number between a minimum and maximum value?
@@ -2336,6 +2276,66 @@ const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 const MEMOIZED_KEY_SEPARATOR = "_";
 const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
+//#region src/internal/function/work.ts
+function asyncFlow(...fns) {
+	assertFlowFunctions(fns);
+	return (...args) => asyncWork(args.map((value) => {
+		if (isError(value)) throw value.error;
+		return isOk(value) ? value.value : value;
+	}), fns, true);
+}
+function flow(...fns) {
+	assertFlowFunctions(fns);
+	return (...args) => work(args.map((value) => {
+		if (isError(value)) throw value.error;
+		return isOk(value) ? value.value : value;
+	}), fns, true);
+}
+async function asyncPipe(value, ...pipes) {
+	assertPipeFunctions(pipes);
+	return asyncWork(value, pipes, false);
+}
+function pipe(value, ...pipes) {
+	assertPipeFunctions(pipes);
+	return work(value, pipes, false);
+}
+async function asyncWork(initial, functions, flow) {
+	const { length } = functions;
+	let transformed = unwrapValue(initial);
+	for (let index = 0; index < length; index += 1) {
+		const fn = functions[index];
+		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
+	}
+	return transformed;
+}
+function unwrapValue(value, flow, nested) {
+	if (typeof value === "function") {
+		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
+		return unwrapValue(value(), flow, true);
+	}
+	if (flow != null && value instanceof Promise) throw new TypeError(flow ? WORK_MESSAGE_FLOW_PROMISE : WORK_MESSAGE_PIPE_PROMISE);
+	if (isError(value)) throw value.error;
+	return isOk(value) ? value.value : value;
+}
+function work(initial, functions, flow) {
+	const { length } = functions;
+	let transformed = unwrapValue(initial, flow);
+	for (let index = 0; index < length; index += 1) {
+		const fn = functions[index];
+		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? fn(...initial) : fn(transformed), flow);
+	}
+	return transformed;
+}
+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);
+flow.async = asyncFlow;
+pipe.async = asyncPipe;
+//#endregion
 //#region src/internal/string/case.ts
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
@@ -2979,7 +2979,9 @@ promises.result = resultPromises;
 //#region src/result/index.ts
 async function asyncAttempt(value, err) {
 	try {
-		let result = typeof value === "function" ? value() : await value;
+		let result;
+		if (typeof value === "function") result = value();
+		else result = value;
 		if (result instanceof Promise) result = await result;
 		return ok(result);
 	} catch (thrown) {
@@ -4492,7 +4494,7 @@ function Observable(beacon) {
 	};
 }
 Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
-Observable.prototype.deactivate = deactiveateObservable;
+Observable.prototype.deactivate = deactivateObservable;
 Observable.prototype.subscribe = subscribeToObservable;
 Object.defineProperty(Observable.prototype, "active", {
 	enumerable: true,
@@ -4541,7 +4543,7 @@ function createObserver(first, second, third) {
 function deactivateBeacon() {
 	closeBeacon(this[BEACON_SYMBOL], false);
 }
-function deactiveateObservable() {
+function deactivateObservable() {
 	this[BEACON_SYMBOL].active = false;
 }
 function emitBeaconError(error, finish) {
@@ -6845,4 +6847,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, 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, 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, isAsyncOnce, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, 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, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, reverseSelect, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, 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, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, 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, isAsyncOnce, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, 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, 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, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, 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 };

package/dist/internal/array/compact.d.mts

@@ -11,7 +11,7 @@
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
  * ```
  */
-export declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | '' | false | null | undefined>>;
+export declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | "" | false | null | undefined>>;
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  *

package/dist/internal/array/find.d.mts

@@ -3,20 +3,20 @@ type FindMapper = {
   callback: unknown;
   reverse: boolean;
 };
-type FindValueType = 'index' | 'item';
+type FindValueType = "index" | "item";
 type FindValuesResult = {
   matched: unknown[];
   notMatched: unknown[];
 };
-type FindValuesType = 'all' | 'unique';
+type FindValuesType = "all" | "unique";
 type Parameters = {
   bool?: unknown;
   key?: unknown;
   value?: unknown;
 };
 export declare function createFindParameters(original: unknown[]): Parameters;
-export declare function findValue(type: Exclude<FindValueType, 'item'>, array: unknown[], parameters: unknown[], reversed: boolean): number;
-export declare function findValue(type: Exclude<FindValueType, 'index'>, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
+export declare function findValue(type: Exclude<FindValueType, "item">, array: unknown[], parameters: unknown[], reversed: boolean): number;
+export declare function findValue(type: Exclude<FindValueType, "index">, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
 export declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
 export declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: FindMapper): FindValuesResult;
 export declare const FIND_VALUE_INDEX = "index";

package/dist/internal/array/index-of.d.mts

@@ -65,9 +65,6 @@ export declare function indexOf<Item>(array: Item[], filter: (item: Item, index:
  * ```
  */
 export declare function indexOf<Item>(array: Item[], item: Item): number;
-export declare namespace indexOf {
-  var last: typeof lastIndexOf;
-}
 /**
  * Get the index of the last matching item by callback
  *
@@ -141,4 +138,7 @@ export declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, in
  * ```
  */
 export declare function lastIndexOf<Item>(array: Item[], item: Item): number;
+export declare namespace indexOf {
+  export var last: typeof lastIndexOf;
+}
 //#endregion

package/dist/internal/array/insert.d.mts

@@ -1,5 +1,5 @@
 //#region src/internal/array/insert.d.ts
-type InsertType = 'insert' | 'push' | 'splice';
+type InsertType = "insert" | "push" | "splice";
 export declare function insertValues(type: InsertType, array: unknown, items: unknown, start: unknown, deleteCount: number): unknown;
 export declare const INSERT_TYPE_INSERT: InsertType;
 export declare const INSERT_TYPE_PUSH: InsertType;

package/dist/internal/array/match.d.mts

@@ -3,7 +3,7 @@ import { PlainObject } from "../../models.mjs";
 /**
  * Comparison of an array within another array
  */
-export type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
+export type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
 /**
  * Is the needle array at the end of the haystack array?
  *

package/dist/internal/array/sets.d.mts

@@ -1,5 +1,5 @@
 //#region src/internal/array/sets.d.ts
-type CompareSetsType = 'difference' | 'intersection' | 'union';
+type CompareSetsType = "difference" | "intersection" | "union";
 export declare function compareSets(type: CompareSetsType, first: unknown[], second: unknown[], key?: unknown): unknown[];
 export declare const SETS_COMPARE_DIFFERENCE: CompareSetsType;
 export declare const SETS_COMPARE_INTERSECTION: CompareSetsType;

package/dist/internal/function/assert.d.mts

@@ -17,13 +17,6 @@ type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path e
  * @param error Error constructor _(defaults to `Error`)_
  */
 export declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
-export declare namespace assert {
-  var condition: typeof assertCondition;
-  var defined: typeof assertDefined;
-  var instanceOf: typeof assertInstanceOf;
-  var is: typeof assertIs;
-  var property: typeof assertProperty;
-}
 /**
  * Creates an _Asserter_ that asserts a condition is true, throwing an error if it is not
  *
@@ -79,4 +72,11 @@ export declare function assertIs<Value>(condition: (value: unknown) => value is
  * @returns _Asserter_
  */
 export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<NestedPick<Value, Path>>;
+export declare namespace assert {
+  export var condition: typeof assertCondition;
+  export var defined: typeof assertDefined;
+  export var instanceOf: typeof assertInstanceOf;
+  export var is: typeof assertIs;
+  export var property: typeof assertProperty;
+}
 //#endregion

package/dist/internal/function/limit.d.mts

@@ -32,7 +32,7 @@ export type Limiter<Callback extends GenericCallback> = {
    */
   run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 };
-type LimiterType = 'debounce' | 'throttle' | 'wait';
+type LimiterType = "debounce" | "throttle" | "wait";
 export declare function getAsyncLimiter<Callback extends GenericAsyncCallback | GenericCallback>(type: LimiterType, callback: Callback, time?: number): AsyncLimiter<Callback>;
 export declare function getLimiter<Callback extends GenericCallback>(type: LimiterType, callback: Callback, time?: number): Limiter<Callback>;
 export declare const LIMITER_DEBOUNCE: LimiterType;

package/dist/internal/function/work.d.mts

@@ -177,9 +177,6 @@ export declare function flow<First extends GenericCallback>(first: First, ...fns
  * @returns _Flow_ function
  */
 export declare function flow(...fns: GenericCallback[]): (...args: unknown[]) => unknown;
-export declare namespace flow {
-  var async: typeof asyncFlow;
-}
 /**
  * Pipe a value through a function
  *
@@ -372,7 +369,10 @@ export declare function pipe<Value>(value: Value, ...pipes: Array<(value: Value)
  * @returns _Piped_ result
  */
 export declare function pipe(value: unknown, ...pipes: Array<(value: unknown) => unknown>): unknown;
+export declare namespace flow {
+  export var async: typeof asyncFlow;
+}
 export declare namespace pipe {
-  var async: typeof asyncPipe;
+  export var async: typeof asyncPipe;
 }
 //#endregion

package/dist/internal/herald.d.mts

@@ -31,7 +31,7 @@ export type Herald<Events extends Record<string, GenericCallback>> = {
    */
   subscribe<Event extends keyof Events>(event: Event, callback: Events[Event], signal?: AbortSignal): Subscription;
 };
-export type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends '*' ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
+export type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends "*" ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
 type HeraldOnCreate<Events extends Record<string, GenericCallback>> = <Event extends keyof Events>(event: Event, callback: Events[Event], subscription: Subscription) => void;
 export type HeraldOptions<Events extends Record<string, GenericCallback>> = {
   names: Array<keyof Events>;

package/dist/internal/math/aggregate.d.mts

@@ -7,8 +7,8 @@ type Aggregation = {
   items?: Record<number, unknown[]>;
   value: number;
 };
-export type AggregationType = 'average' | 'max' | 'min' | 'sum';
-type NonAverageAggregationType = 'max' | 'min' | 'sum';
+export type AggregationType = "average" | "max" | "min" | "sum";
+type NonAverageAggregationType = "max" | "min" | "sum";
 export declare function aggregate(type: AggregationType, array: unknown[], key: unknown, first?: unknown): Aggregation;
 export declare function getAggregateCallback(key: unknown): Function | undefined;
 export declare function getAggregated(type: NonAverageAggregationType, array: unknown[], key?: unknown, first?: unknown): unknown;

package/dist/internal/result/misc.d.mts

@@ -15,9 +15,6 @@ export declare function error<E>(value: E, original: Error): ExtendedErr<E>;
  * @returns Error result
  */
 export declare function error<E>(value: E): Err<E>;
-export declare namespace error {
-  var is: typeof isError;
-}
 export declare function getError<E>(value: E, original?: Error): Err<E> | ExtendedErr<E>;
 /**
  * Is the _Result_ an extended error?
@@ -78,9 +75,6 @@ export declare function isResult(value: unknown): value is ExtendedErr<unknown>
  * @returns Ok result
  */
 export declare function ok<Value>(value: Value): Ok<Value>;
-export declare namespace ok {
-  var is: typeof isOk;
-}
 /**
  * Gets the value of an ok result _(or a default value)_
  *
@@ -97,4 +91,10 @@ export declare function unwrap<Value, E = Error>(value: Result<Value, E>, defaul
  * @returns Value of the _Result_ _(or the default value)_
  */
 export declare function unwrap(value: unknown, defaultValue: unknown): unknown;
+export declare namespace error {
+  export var is: typeof isError;
+}
+export declare namespace ok {
+  export var is: typeof isOk;
+}
 //#endregion

package/dist/internal/sized/map.d.mts

@@ -39,10 +39,10 @@ export declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends
   /**
    * @inheritdoc
    */
-  get(key: SizedKey): SizedValue | undefined;
+  override get(key: SizedKey): SizedValue | undefined;
   /**
    * @inheritdoc
    */
-  set(key: SizedKey, value: SizedValue): this;
+  override set(key: SizedKey, value: SizedValue): this;
 }
 //#endregion

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

@@ -1,4 +1,5 @@
-import { Constructor, GenericCallback } from "../../models.mjs";
+import { Constructor } from "../../models.mjs";
+import { CompareHandler } from "./handlers.mjs";
 //#region src/internal/value/compare.d.ts
 type Comparator<Value = any> = (first: Value, second: Value) => number;
 /**
@@ -9,24 +10,6 @@ type Comparator<Value = any> = (first: Value, second: Value) => number;
  * @returns `0` if equal; `-1` first comes before second; `1` first comes after second
  */
 export declare function compare(first: unknown, second: unknown): number;
-export declare namespace compare {
-  var deregister: typeof deregisterComparator;
-  var handler: {
-    base: {
-      handlers: WeakMap<WeakKey, string | GenericCallback>;
-      options: {
-        callback: GenericCallback;
-        method?: string;
-      };
-      owner: GenericCallback;
-      deregister: (constructor: Constructor) => void;
-      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
-      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    };
-    handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
-  };
-  var register: typeof registerComparator;
-}
 /**
  * Deregister a custom comparison handler for a class
  *
@@ -44,4 +27,9 @@ export declare function deregisterComparator<Instance>(constructor: Constructor<
  * @param handler Method name or comparison function _(defaults to `compare`)_
  */
 export declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
+export declare namespace compare {
+  export var deregister: typeof deregisterComparator;
+  export var handler: CompareHandler<number>;
+  export var register: typeof registerComparator;
+}
 //#endregion

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

@@ -1,4 +1,5 @@
-import { Constructor, GenericCallback } from "../../models.mjs";
+import { Constructor } from "../../models.mjs";
+import { CompareHandler } from "./handlers.mjs";
 //#region src/internal/value/equal.d.ts
 /**
  * Options for value equality comparison
@@ -54,17 +55,6 @@ type Equalizer = {
    */
   register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
 };
-type Options = {
-  ignoreCase: boolean;
-  ignoreExpressions: OptionsKeys<RegExp[]>;
-  ignoreKeys: OptionsKeys<Set<string>>;
-  relaxedNullish: boolean;
-};
-type OptionsKeys<Values> = {
-  enabled: boolean;
-  values: Values;
-};
-declare function Equalizer(this: any, options: Options): void;
 /**
  * Deregister a equality comparison handler for a specific class
  *
@@ -91,25 +81,6 @@ export declare function equal(first: string, second: string, ignoreCase?: boolea
  * @returns `true` if the values are equal, otherwise `false`
  */
 export declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
-export declare namespace equal {
-  var deregister: typeof deregisterEqualizer;
-  var handler: {
-    base: {
-      handlers: WeakMap<WeakKey, string | GenericCallback>;
-      options: {
-        callback: GenericCallback;
-        method?: string;
-      };
-      owner: GenericCallback;
-      deregister: (constructor: Constructor) => void;
-      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
-      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    };
-    handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
-  };
-  var initialize: typeof initializeEqualizer;
-  var register: typeof registerEqualizer;
-}
 /**
  * Create an equalizer with predefined options
  *
@@ -128,4 +99,10 @@ export declare function initializeEqualizer(options?: EqualOptions): Equalizer;
  * @param handler Comparison function
  */
 export declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
+export declare namespace equal {
+  export var deregister: typeof deregisterEqualizer;
+  export var handler: CompareHandler<boolean>;
+  export var initialize: typeof initializeEqualizer;
+  export var register: typeof registerEqualizer;
+}
 //#endregion

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

@@ -12,17 +12,14 @@ type BaseHandlerOptions = {
   callback: GenericCallback;
   method?: string;
 };
-type CompareHandler<Value> = {
+export type CompareHandler<Value> = {
   base: BaseHandler;
   handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
 };
-type ValueHandler = {
+export type ValueHandler = {
   base: BaseHandler;
   handle(value: unknown, ...parameters: unknown[]): unknown;
 };
-declare function BaseHandler(this: any, owner: GenericCallback, options: BaseHandlerOptions): void;
-declare function CompareHandler(this: any, base: BaseHandler): void;
-declare function ValueHandler(this: any, value: BaseHandler): void;
 export declare function createCompareHandler<Value>(owner: GenericCallback, options: BaseHandlerOptions): CompareHandler<Value>;
 export declare function createValueHandler(owner: GenericCallback, options: BaseHandlerOptions): ValueHandler;
 //#endregion

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

@@ -38,9 +38,6 @@ export declare function hasValue<Data extends PlainObject, Path extends NestedKe
  * ```
  */
 export declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
-export declare namespace hasValue {
-  var get: typeof hasValueResult;
-}
 /**
  * Check if a property is defined in an object, and get its value if it is
  *
@@ -83,4 +80,7 @@ export declare function hasValueResult<Data extends PlainObject, Path extends Ne
  * ```
  */
 export declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
+export declare namespace hasValue {
+  export var get: typeof hasValueResult;
+}
 //#endregion