@oscarpalmer/atoms 0.202.0 → 0.204.0

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

@@ -18,7 +18,7 @@ import { Result } from "../result/models.mjs";
  * hasValue(data, 'foo.nope');    // => false
  * ```
  */
-declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): boolean;
+export declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): boolean;
 /**
  * Check if a property is defined in an object
  *
@@ -37,8 +37,8 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  * hasValue(data, 'foo.nope');          // => false
  * ```
  */
-declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
-declare namespace hasValue {
+export declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
+export declare namespace hasValue {
   var get: typeof hasValueResult;
 }
 /**
@@ -61,7 +61,7 @@ declare namespace hasValue {
  * hasValueResult(data, 'foo.nope');    // => {ok: false, error: 'Expected property to exist in object'}
  * ```
  */
-declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): Result<NestedValue<Data, ToString<Path>>, string>;
+export declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): Result<NestedValue<Data, ToString<Path>>, string>;
 /**
  * Check if a property is defined in an object, and get its value if it is
  *
@@ -82,6 +82,5 @@ declare function hasValueResult<Data extends PlainObject, Path extends NestedKey
  * hasValueResult(data, 'foo.nope');          // => {ok: false, error: 'Expected property to exist in object'}
  * ```
  */
-declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
-//#endregion
-export { hasValue, hasValueResult };
+export declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
+//#endregion

package/dist/internal/value/has.mjs

@@ -7,6 +7,5 @@ function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 hasValue.get = hasValueResult;
-Object.defineProperty(hasValue, "get", { value: hasValueResult });
 //#endregion
 export { hasValue, hasValueResult };

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

@@ -1,9 +1,8 @@
 import { Result } from "../result/models.mjs";
 //#region src/internal/value/misc.d.ts
-declare function findKey(needle: string, haystack: object): string;
-declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;
-declare function getPaths(path: string, lowercase: boolean): string | string[];
-declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, string>;
-declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;
-//#endregion
-export { findKey, getNestedValue, getPaths, handleValue };
+export declare function findKey(needle: string, haystack: object): string;
+export declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;
+export declare function getPaths(path: string, lowercase: boolean): string | string[];
+export declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<object, string>;
+export declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;
+//#endregion

package/dist/internal/value/misc.mjs

@@ -30,9 +30,10 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
 		if (ignoreKey(path)) return error(MISC_NESTED_MESSAGE_UNSAFE);
-		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(MISC_NESTED_MESSAGE_MISSING);
-		data[key] = typeof value === "function" ? value(data[key]) : value;
+		const dataObject = data;
+		const key = ignoreCase ? findKey(path, dataObject) : path;
+		if (get) return key in dataObject ? ok(dataObject[key]) : error(MISC_NESTED_MESSAGE_MISSING);
+		dataObject[key] = typeof value === "function" ? value(dataObject[key]) : value;
 	}
 	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }

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

@@ -1,5 +1,4 @@
 //#region src/internal/value/partial.d.ts
-declare function partial<Value extends object, ValueKey extends keyof Value>(value: unknown, keys: ValueKey[], omit: true): Omit<Value, ValueKey>;
-declare function partial<Value extends object, ValueKey extends keyof Value>(value: unknown, keys: ValueKey[], omit: false): Pick<Value, ValueKey>;
-//#endregion
-export { partial };
+export declare function partial<Value extends object, ValueKey extends keyof Value>(value: unknown, keys: ValueKey[], omit: true): Omit<Value, ValueKey>;
+export declare function partial<Value extends object, ValueKey extends keyof Value>(value: unknown, keys: ValueKey[], omit: false): Pick<Value, ValueKey>;
+//#endregion

package/dist/internal/value/partial.mjs

@@ -1,6 +1,7 @@
+import { isPlainObject } from "../is.mjs";
 //#region src/internal/value/partial.ts
 function partial(value, providedKeys, omit) {
-	if (typeof value !== "object" || value === null) return {};
+	if (!isPlainObject(value)) return {};
 	const keys = omit ? Object.keys(value) : Array.isArray(providedKeys) ? providedKeys : [];
 	const { length } = keys;
 	if (length === 0) return omit ? value : {};

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

@@ -15,7 +15,7 @@ import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
  * setValue(data, 'foo.bar.baz', (current) => current + 1); // => {foo: {bar: {baz: 43}}}
  * ```
  */
-declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, updater: (current: NestedValue<Data, Path>) => NestedValue<Data, Path>): Data;
+export declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, updater: (current: NestedValue<Data, Path>) => NestedValue<Data, Path>): Data;
 /**
  * Set the value in an object using a known path
  *
@@ -31,7 +31,7 @@ declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data
  * setValue(data, 'foo.bar.baz', 99); // => {foo: {bar: {baz: 99}}}
  * ```
  */
-declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, value: NestedValue<Data, Path>): Data;
+export declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, value: NestedValue<Data, Path>): Data;
 /**
  * Set the value in an object using an unknown path
  *
@@ -48,6 +48,5 @@ declare function setValue<Data extends PlainObject, Path extends NestedKeys<Data
  * setValue(data, 'Foo.Bar.Baz', 99, true); // => {foo: {bar: {baz: 99}}}
  * ```
  */
-declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
-//#endregion
-export { setValue };
+export declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
+//#endregion

package/dist/internal/value/set.mjs

@@ -1,3 +1,4 @@
+import { unwrap } from "../result/misc.mjs";
 import { getPaths, handleValue } from "./misc.mjs";
 //#region src/internal/value/set.ts
 function setValue(data, path, value, ignoreCase) {
@@ -17,7 +18,7 @@ function setValue(data, path, value, ignoreCase) {
 			handleValue(target, currentPath, value, false, shouldIgnoreCase);
 			break;
 		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
+		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
 			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);

package/dist/is.d.mts

@@ -6,83 +6,83 @@ import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNonArrayOrP
  * @param value Value to check
  * @returns `true` if the value is considered empty, otherwise `false`
  */
-declare function isEmpty(value: unknown): boolean;
+export declare function isEmpty(value: unknown): boolean;
 /**
  * Is the value not empty, or holding non-empty values?
  *
  * @param value Value to check
  * @returns `true` if the value is not considered empty, otherwise `false`
  */
-declare function isNonEmpty(value: unknown): boolean;
+export declare function isNonEmpty(value: unknown): boolean;
 /**
  * Is the value not `undefined` or `null`?
  *
  * @param value Value to check
  * @returns `true` if the value is not `undefined` or `null`, otherwise `false`
  */
-declare function isNonNullable<Value>(value: Value): value is Exclude<Value, undefined | null>;
+export declare function isNonNullable<Value>(value: Value): value is Exclude<Value, undefined | null>;
 /**
  * Is the value not `undefined`, `null`, or stringified as an empty _(no whitespace)_ string?
  *
  * @param value Value to check
  * @returns `true` if the value is not `undefined`, `null`, or matches an empty string, otherwise `false`
  */
-declare function isNonNullableOrEmpty<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
+export declare function isNonNullableOrEmpty<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
 /**
  * Is the value not `undefined`, `null`, or stringified as a whitespace-only string?
  *
  * @param value Value to check
  * @returns `true` if the value is not `undefined`, `null`, or matches a whitespace-only string, otherwise `false`
  */
-declare function isNonNullableOrWhitespace<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
+export declare function isNonNullableOrWhitespace<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
 /**
  * Is the value not a number or a number-like string?
  *
  * @param value Value to check
  * @returns `true` if the value is not a number or a number-like string, otherwise `false`
  */
-declare function isNonNumerical<Value>(value: Value): value is Exclude<Value, number | `${number}`>;
+export declare function isNonNumerical<Value>(value: Value): value is Exclude<Value, number | `${number}`>;
 /**
  * Is the value not an object _(or function)_?
  *
  * @param value Value to check
  * @returns `true` if the value is not an object, otherwise `false`
  */
-declare function isNonObject<Value>(value: Value): value is Exclude<Value, object>;
+export declare function isNonObject<Value>(value: Value): value is Exclude<Value, object>;
 /**
  * Is the value `undefined` or `null`?
  *
  * @param value Value to check
  * @returns `true` if the value is `undefined` or `null`, otherwise `false`
  */
-declare function isNullable(value: unknown): value is undefined | null;
+export declare function isNullable(value: unknown): value is undefined | null;
 /**
  * Is the value `undefined`, `null`, or stringified as an empty _(no whitespace)_ string?
  *
  * @param value Value to check
  * @returns `true` if the value is nullable or matches an empty string, otherwise `false`
  */
-declare function isNullableOrEmpty(value: unknown): value is undefined | null | '';
+export declare function isNullableOrEmpty(value: unknown): value is undefined | null | '';
 /**
  * Is the value `undefined`, `null`, or stringified as a whitespace-only string?
  *
  * @param value Value to check
  * @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
  */
-declare function isNullableOrWhitespace(value: unknown): value is undefined | null | '';
+export declare function isNullableOrWhitespace(value: unknown): value is undefined | null | '';
 /**
  * Is the value a number or a number-like string?
  *
  * @param value Value to check
  * @returns `true` if the value is a number or a number-like string, otherwise `false`
  */
-declare function isNumerical(value: unknown): value is number | `${number}`;
+export declare function isNumerical(value: unknown): value is number | `${number}`;
 /**
  * Is the value an object _(or function)_?
  *
  * @param value Value to check
  * @returns `true` if the value matches, otherwise `false`
  */
-declare function isObject(value: unknown): value is object;
+export declare function isObject(value: unknown): value is object;
 //#endregion
-export { isArrayOrPlainObject, isConstructor, isEmpty, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isPlainObject, isPrimitive, isTypedArray };
+export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonInstanceOf, isNonKey, isNonNumber, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNumber, isPlainObject, isPrimitive, isTypedArray };

package/dist/logger.d.mts

@@ -46,12 +46,12 @@ type Logger = {
    * @param label Label for the logger
    * @returns _TimedLogger_ instance
    */
-  time(label: string): TimedLogger;
+  time(label: string): TimeLogger;
 };
 /**
  * A named timer that can be used to log durations to the console
  */
-type TimedLogger = {
+type TimeLogger = {
   /**
    * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
    */
@@ -67,8 +67,9 @@ type TimedLogger = {
    */
   get stop(): () => void;
 };
+declare function TimeLogger(this: any, label: string): void;
 declare function isLogger(value: unknown): value is Logger;
-declare function isTimedLogger(value: unknown): value is TimedLogger;
+declare function isTimeLogger(value: unknown): value is TimeLogger;
 /**
  * A logger that can be used to log messages to the console
  *
@@ -76,4 +77,4 @@ declare function isTimedLogger(value: unknown): value is TimedLogger;
  */
 declare const Logger: Logger;
 //#endregion
-export { Logger, type TimedLogger, isLogger, isTimedLogger };
+export { Logger, type TimeLogger, isLogger, isTimeLogger };

package/dist/logger.mjs

@@ -1,82 +1,90 @@
 import { noop } from "./internal/function/misc.mjs";
 import { getString } from "./internal/string/misc.mjs";
 //#region src/logger.ts
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
+function Lumberjack() {}
+Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+Lumberjack.prototype.time = getTimeLogger;
+Object.defineProperties(Lumberjack.prototype, {
+	debug: { get: getLoggerCallback.bind("debug") },
+	dir: { get: getLoggerCallback.bind("dir") },
+	error: { get: getLoggerCallback.bind("error") },
+	enabled: {
+		enumerable: true,
+		get: getLoggerEnabled,
+		set: setLoggerEnabled
+	},
+	info: { get: getLoggerCallback.bind("info") },
+	log: { get: getLoggerCallback.bind("log") },
+	table: { get: getLoggerCallback.bind("table") },
+	trace: { get: getLoggerCallback.bind("trace") },
+	warn: { get: getLoggerCallback.bind("warn") }
+});
+function TimeLogger(label) {
+	this[LOGGER_SYMBOL] = {
+		label,
+		started: enabled,
+		stopped: false
+	};
+	this[LOGGER_SYMBOL].isActive = () => {
+		return enabled && this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped;
+	};
+	if (this[LOGGER_SYMBOL].started) console.time(label);
+}
+TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
+Object.defineProperties(TimeLogger.prototype, {
+	active: {
+		enumerable: true,
+		get: getTimeLoggerActive
+	},
+	log: { get: getTimerLoggerLog },
+	stop: { get: getTimeLoggerStop }
+});
+function getLoggerCallback() {
+	return enabled ? console[this].bind(console) : noop;
+}
+function getLoggerEnabled() {
+	return enabled;
+}
+function getTimeLogger(label) {
+	return new TimeLogger(getString(label));
+}
+function getTimeLoggerActive() {
+	return this[LOGGER_SYMBOL].isActive();
+}
+function getTimerLoggerLog() {
+	const state = this[LOGGER_SYMBOL];
+	return state.isActive() ? console.timeLog.bind(console, state.label) : noop;
+}
+function getTimeLoggerStop() {
+	const state = this[LOGGER_SYMBOL];
+	if (state.isActive()) {
+		state.stopped = true;
+		return console.timeEnd.bind(console, state.label);
+	}
+	return noop;
+}
 function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
+	return typeof value === "object" && value !== null && LOGGER_PROPERTY in value && value[LOGGER_PROPERTY] === name;
 }
-function isTimedLogger(value) {
+function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
-function timedLogger(label) {
-	function stop() {
-		const fn = stopper;
-		state.stopped = true;
-		logger = void 0;
-		stopper = void 0;
-		return fn;
-	}
-	let logger = console.timeLog.bind(console, label);
-	let stopper = console.timeEnd.bind(console, label);
-	const state = {
-		label,
-		started: enabled,
-		stopped: false
-	};
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
-		active: {
-			enumerable: true,
-			get: () => state.started && !state.stopped && enabled
-		},
-		log: { get: () => instance.active ? logger : noop },
-		stop: { get: () => instance.active ? stop() : noop }
-	});
-	if (state.started) console.time(label);
-	return Object.freeze(instance);
+function setLoggerEnabled(value) {
+	enabled = typeof value === "boolean" ? value : enabled;
 }
-const LOGGER_NAME = "Logger";
-const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
-const methods = [
-	"debug",
-	"dir",
-	"error",
-	"info",
-	"log",
-	"table",
-	"trace",
-	"warn"
-];
+const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
 /**
 * A logger that can be used to log messages to the console
 *
 * _(Logging can be enabled or disabled by setting the `enabled` property)_
 */
-const Logger = (() => {
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
-		enabled: {
-			enumerable: true,
-			get: () => enabled,
-			set: (value) => {
-				enabled = typeof value === "boolean" ? value : enabled;
-			}
-		},
-		time: { value: (label) => timedLogger(getString(label)) }
-	});
-	for (const method of methods) Object.defineProperty(instance, method, {
-		enumerable: true,
-		get() {
-			return enabled ? console[method].bind(console) : noop;
-		}
-	});
-	return Object.freeze(instance);
-})();
+const Logger = new Lumberjack();
 let enabled = true;
 //#endregion
-export { Logger, isLogger, isTimedLogger };
+export { Logger, isLogger, isTimeLogger };

package/dist/math.d.mts

@@ -9,7 +9,7 @@ import { round } from "./internal/math/misc.mjs";
  * @param callback Callback to get an item's value
  * @returns Average value, or `Number.NaN` if no average can be calculated
  */
-declare function average<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+export declare function average<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the average value from a list of items
  *
@@ -17,14 +17,14 @@ declare function average<Item>(items: Item[], callback: (item: Item, index: numb
  * @param key Key to use for value
  * @returns Average value, or `Number.NaN` if no average can be calculated
  */
-declare function average<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
+export declare function average<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the average value from a list of numbers
  *
  * @param numbers List of numbers
  * @returns Average value, or `Number.NaN` if no average can be calculated
  */
-declare function average(numbers: number[]): number;
+export declare function average(numbers: number[]): number;
 /**
  * Round a number up
  *
@@ -32,7 +32,7 @@ declare function average(numbers: number[]): number;
  * @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
  */
-declare function ceil(value: number, decimals?: number): number;
+export declare function ceil(value: number, decimals?: number): number;
 /**
  * Count the number of items in an array that match a specific value
  *
@@ -41,7 +41,7 @@ declare function ceil(value: number, decimals?: number): number;
  * @param value Value to match and count
  * @returns Number of items that match the condition, or `Number.NaN` if no count can be calculated
  */
-declare function count<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown, value: unknown): number;
+export declare function count<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown, value: unknown): number;
 /**
  * Count the number of items in an array that have a specific value
  *
@@ -50,14 +50,14 @@ declare function count<Item>(array: Item[], callback: (item: Item, index: number
  * @param value Value to match and count
  * @returns Number of items with the specified key value, or `Number.NaN` if no count can be calculated
  */
-declare function count<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+export declare function count<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Count the number of items in an array
  *
  * @param values Array to count for
  * @returns Number of items, or `Number.NaN` if no count can be calculated
  */
-declare function count(values: unknown[]): number;
+export declare function count(values: unknown[]): number;
 /**
  * Round a number down
  *
@@ -65,7 +65,7 @@ declare function count(values: unknown[]): number;
  * @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
  */
-declare function floor(value: number, decimals?: number): number;
+export declare function floor(value: number, decimals?: number): number;
 /**
  * Get the median value from a list of items
  *
@@ -73,7 +73,7 @@ declare function floor(value: number, decimals?: number): number;
  * @param callback Callback to get an item's value
  * @returns Median value, or `Number.NaN` if no median can be calculated
  */
-declare function median<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+export declare function median<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the median value from a list of items
  *
@@ -81,14 +81,14 @@ declare function median<Item>(array: Item[], callback: (item: Item, index: numbe
  * @param key Key to use for value
  * @returns Median value, or `Number.NaN` if no median can be calculated
  */
-declare function median<Item extends PlainObject>(array: Item[], key: keyof NumericalValues<Item>): number;
+export declare function median<Item extends PlainObject>(array: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the median value from a list of numbers
  *
  * @param array List of numbers
  * @returns Median value, or `Number.NaN` if no median can be calculated
  */
-declare function median(array: number[]): number;
+export declare function median(array: number[]): number;
 /**
  * Get the minimum value from a list of items
  *
@@ -97,7 +97,7 @@ declare function median(array: number[]): number;
  * @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
  */
-declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
+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
  *
@@ -106,7 +106,7 @@ declare function min<Item>(items: Item[], callback: (item: Item, index: number,
  * @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
  */
-declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
+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
  *
@@ -114,7 +114,7 @@ declare function min<Item extends PlainObject>(items: Item[], key: keyof Numeric
  * @param callback Callback to get an item's value
  * @returns Items with the minimum value
  */
-declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+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
  *
@@ -122,14 +122,14 @@ declare function min<Item>(items: Item[], callback: (item: Item, index: number,
  * @param key Key to use for value
  * @returns Items with the minimum value
  */
-declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
+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
  */
-declare function min(values: number[]): number;
+export declare function min(values: number[]): number;
 /**
  * Get the sum of a list of items
  *
@@ -137,7 +137,7 @@ declare function min(values: number[]): number;
  * @param callback Callback to get an item's value
  * @returns Sum of the values, or `Number.NaN` if no sum can be calculated
  */
-declare function sum<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+export declare function sum<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the sum of a list of items
  *
@@ -145,13 +145,13 @@ declare function sum<Item>(items: Item[], callback: (item: Item, index: number,
  * @param key Key to use for value
  * @returns Sum of the values, or `Number.NaN` if no sum can be calculated
  */
-declare function sum<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
+export declare function sum<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
 /**
  * Get the sum of a list of numbers
  *
  * @param values List of numbers
  * @returns Sum of the numbers, or `Number.NaN` if no sum can be calculated
  */
-declare function sum(values: number[]): number;
+export declare function sum(values: number[]): number;
 //#endregion
-export { average, ceil, count, floor, max, median, min, round, sum };
+export { max, round };