@oscarpalmer/atoms 0.204.1 → 0.206.0

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/insert.mjs

@@ -1,8 +1,9 @@
 import { chunk } from "./chunk.mjs";
+import { max, min } from "../math/aggregate.mjs";
 //#region src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
 	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
-	const actualStart = Math.min(Math.max(0, start), array.length);
+	const actualStart = min([max([0, start]), array.length]);
 	const chunked = chunk(items);
 	const lastIndex = chunked.length - 1;
 	let index = chunked.length;

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/limit.mjs

@@ -1,3 +1,4 @@
+import { asyncAttempt } from "../result/attempt.mjs";
 import { getNumberOrDefault } from "../defaults.mjs";
 //#region src/internal/function/limit.ts
 const LIMITER_NAME_ASYNC = "asyncLimiter";
@@ -51,15 +52,14 @@ async function handleAsyncLimiter(state, item) {
 	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
 		state.start = state.throttle ? now : void 0;
 		item.running = true;
-		try {
-			let result = state.callback(...item.parameters);
-			if (result instanceof Promise) result = await result;
-			item.resolve(result);
-		} catch (error) {
-			item.reject(error);
-		} finally {
-			item.running = false;
-		}
+		const result = await asyncAttempt(async () => {
+			let value = state.callback(...item.parameters);
+			if (value instanceof Promise) value = await value;
+			return value;
+		});
+		if (result.ok) item.resolve(result.value);
+		else item.reject(result.error);
+		item.running = false;
 	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
 }
 function handleLimiter(state) {

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;
@@ -99,6 +99,47 @@ export declare function max<Item extends PlainObject>(items: Item[], key: keyof
  * @returns Maximum value, or `Number.NaN` if no maximum can be found
  */
 export declare function max(values: number[]): number;
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @param first Return only the first item with the minimum value
+ * @returns First item with the minimum value, or `undefined` if no minimum can be found
+ */
+export declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @param first Return only the first item with the minimum value
+ * @returns First item with the minimum value, or `undefined` if no minimum can be found
+ */
+export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @returns Items with the minimum value
+ */
+export declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @returns Items with the minimum value
+ */
+export declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
+/**
+ * Get the minimum value from a list of numbers
+ *
+ * @param values List of numbers
+ * @returns Minimum value, or `Number.NaN` if no minimum can be found
+ */
+export declare function min(values: number[]): number;
 export declare const AGGREGATION_AVERAGE: AggregationType;
 export declare const AGGREGATION_MAX = "max";
 export declare const AGGREGATION_MIN = "min";

package/dist/internal/math/aggregate.mjs

@@ -59,6 +59,9 @@ function isMinValue(aggregation, value) {
 function max(array, key, first) {
 	return getAggregated("max", array, key, first);
 }
+function min(array, key, first) {
+	return getAggregated("min", array, key, first);
+}
 const AGGREGATION_AVERAGE = "average";
 const AGGREGATION_MAX = "max";
 const AGGREGATION_MIN = "min";
@@ -70,4 +73,4 @@ const aggregators = {
 	sum: calculateSum
 };
 //#endregion
-export { AGGREGATION_AVERAGE, AGGREGATION_MAX, AGGREGATION_MIN, AGGREGATION_SUM, aggregate, getAggregateCallback, getAggregated, max };
+export { AGGREGATION_AVERAGE, AGGREGATION_MAX, AGGREGATION_MIN, AGGREGATION_SUM, aggregate, getAggregateCallback, getAggregated, max, min };

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

@@ -1,4 +1,12 @@
 //#region src/internal/math/misc.d.ts
+/**
+ * Round a number down
+ *
+ * @param value Number to round down
+ * @param decimals Number of decimal places to round to _(defaults to `0`)_
+ * @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+ */
+export declare function floor(value: number, decimals?: number): number;
 /**
  * Round a number
  *

package/dist/internal/math/misc.mjs

@@ -1,5 +1,15 @@
 //#region src/internal/math/misc.ts
 /**
+* Round a number down
+*
+* @param value Number to round down
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function floor(value, decimals) {
+	return roundNumber(Math.floor, value, decimals);
+}
+/**
 * Round a number
 *
 * @param value Number to round
@@ -16,4 +26,4 @@ function roundNumber(callback, value, decimals) {
 	return callback((value + Number.EPSILON) * mod) / mod;
 }
 //#endregion
-export { round, roundNumber };
+export { floor, round, roundNumber };

package/dist/internal/random.mjs

@@ -1,4 +1,5 @@
 import { isNumber } from "./is.mjs";
+import { floor } from "./math/misc.mjs";
 //#region src/internal/random.ts
 function getRandomFloatingNumberValue(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
@@ -25,7 +26,7 @@ function getRandomFloatingNumber(minimum, maximum) {
 * @returns Random integer
 */
 function getRandomInteger(minimum, maximum) {
-	return Math.floor(getRandomFloatingNumberValue(true, minimum, maximum));
+	return floor(getRandomFloatingNumberValue(true, minimum, maximum));
 }
 //#endregion
 export { getRandomFloatingNumber, getRandomInteger };

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

@@ -0,0 +1,59 @@
+import { ExtendedResult, Result } from "./models.mjs";
+//#region src/internal/result/attempt.d.ts
+/**
+ * Executes a _Promise_, catching any errors, and returns a result
+ *
+ * _Available as `asyncAttempt` and `attempt.async`_
+ *
+ * @param promise _Promise_ to execute
+ * @param error Error value
+ * @returns Callback result
+ */
+export declare function asyncAttempt<Value, E>(promise: Promise<Value>, error: E): Promise<ExtendedResult<Awaited<Value>, E>>;
+/**
+ * Executes a callback asynchronously, catching any errors, and returns a result
+ *
+ * _Available as `asyncAttempt` and `attempt.async`_
+ *
+ * @param callback Callback to execute
+ * @param error Error value
+ * @returns Callback result
+ */
+export declare function asyncAttempt<Value, E>(callback: () => Promise<Value>, error: E): Promise<ExtendedResult<Awaited<Value>, E>>;
+/**
+ * Executes a _Promise_, catching any errors, and returns a result
+ *
+ * _Available as `asyncAttempt` and `attempt.async`_
+ *
+ * @param promise _Promise_ to execute
+ * @returns Callback result
+ */
+export declare function asyncAttempt<Value>(promise: Promise<Value>): Promise<Result<Awaited<Value>>>;
+/**
+ * Executes a callback asynchronously, catching any errors, and returns a result
+ *
+ * _Available as `asyncAttempt` and `attempt.async`_
+ *
+ * @param callback Callback to execute
+ * @returns Callback result
+ */
+export declare function asyncAttempt<Value>(callback: () => Promise<Value>): Promise<Result<Awaited<Value>>>;
+/**
+ * Executes a callback, catching any errors, and returns a result
+ *
+ * @param callback Callback to execute
+ * @param error Error value
+ * @returns Callback result
+ */
+export declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedResult<Value, E>;
+/**
+ * Executes a callback, catching any errors, and returns a result
+ *
+ * @param callback Callback to execute
+ * @returns Callback result
+ */
+export declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
+export declare namespace attempt {
+  export var async: typeof asyncAttempt;
+}
+//#endregion

package/dist/internal/result/attempt.mjs

@@ -0,0 +1,24 @@
+import { getError, ok } from "./misc.mjs";
+//#region src/internal/result/attempt.ts
+async function asyncAttempt(value, err) {
+	try {
+		let result;
+		if (typeof value === "function") result = value();
+		else result = value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		const value = callback();
+		return ok(value);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+attempt.async = asyncAttempt;
+//#endregion
+export { asyncAttempt, attempt };

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/string/misc.mjs

@@ -1,3 +1,6 @@
+import { unwrap } from "../result/misc.mjs";
+import "../../result/misc.mjs";
+import { attempt } from "../result/attempt.mjs";
 //#region src/internal/string/misc.ts
 /**
 * Get the string value from any value
@@ -57,11 +60,7 @@ function join(array, delimiter) {
 	return values.join(typeof delimiter === "string" ? delimiter : "");
 }
 function tryCallback(value, callback) {
-	try {
-		return callback(value);
-	} catch {
-		return value;
-	}
+	return unwrap(attempt(() => callback(value)), value);
 }
 function tryDecode(value) {
 	return tryCallback(value, decodeURIComponent);

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/equal.mjs

@@ -1,4 +1,5 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
+import { round } from "../math/misc.mjs";
 import { createCompareHandler } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
 function Equalizer(options) {
@@ -60,7 +61,7 @@ function equalArray(first, second, options) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= EQUAL_ARRAY_THRESHOLD) {
-		offset = Math.round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
+		offset = round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
 		offset = offset > EQUAL_ARRAY_THRESHOLD ? EQUAL_ARRAY_THRESHOLD : offset;
 		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
 	}

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

package/dist/internal/value/misc.mjs

@@ -1,5 +1,5 @@
-import { ignoreKey } from "../string/misc.mjs";
 import { error, ok } from "../result/misc.mjs";
+import { ignoreKey } from "../string/misc.mjs";
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
 	const keys = Object.keys(haystack);