@oscarpalmer/atoms 0.154.0 → 0.155.0

package/dist/atoms.full.js

@@ -86,6 +86,15 @@ function isConstructor(value) {
 	return typeof value === "function" && value.prototype?.constructor === value;
 }
 /**
+* Is the value an instance of the constructor?
+* @param constructor Class constructor
+* @param value Value to check
+* @returns `true` if the value is an instance of the constructor, otherwise `false`
+*/
+function isInstanceOf(constructor, value) {
+	return isConstructor(constructor) && value instanceof constructor;
+}
+/**
 * Is the value a key?
 * @param value Value to check
 * @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
@@ -1036,24 +1045,64 @@ function isOk(value) {
 function isResult(value) {
 	return _isResult(value, true) || _isResult(value, false);
 }
+/**
+* Asserts that a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+*/
 function assert(condition, message, error) {
 	if (!condition()) throw new (error ?? Error)(message);
 }
-assert.condition = (condition, message, error) => {
+assert.condition = assertCondition;
+assert.defined = assertDefined;
+assert.instanceOf = assertInstanceOf;
+assert.is = assertIs;
+/**
+* Creates an asserter that asserts a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertCondition(condition, message, error) {
 	return (value) => {
 		assert(() => condition(value), message, error);
 	};
-};
-assert.instanceOf = (constructor, message, error) => {
+}
+/**
+* Asserts that a value is defined throwing an error if it is not
+* @param value Value to assert
+* @param message Error message
+*/
+function assertDefined(value, message) {
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
+}
+/**
+* Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
+* @param constructor Constructor to check against
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertInstanceOf(constructor, message, error) {
 	return (value) => {
 		assert(() => value instanceof constructor, message, error);
 	};
-};
-assert.is = (condition, message, error) => {
+}
+/**
+* Creates an asserter that asserts a value is of a specific type, throwing an error if it is not
+* @param condition Type guard function to check the value
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertIs(condition, message, error) {
 	return (value) => {
 		assert(() => condition(value), message, error);
 	};
-};
+}
+const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 function asyncFlow(...fns) {
 	assertFlowFunctions(fns);
 	return (...args) => asyncWork(args.map((value) => {
@@ -1284,6 +1333,27 @@ function findKey(needle, haystack) {
 	const index = keys.map((key) => key.toLowerCase()).indexOf(needle.toLowerCase());
 	return index > -1 ? keys[index] : needle;
 }
+function getNestedValue(data, path, ignoreCase) {
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return {
+		exists: false,
+		value: void 0
+	};
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
+	const { length } = paths;
+	let current = data;
+	for (let index = 0; index < length; index += 1) {
+		const part = paths[index];
+		const handled = handleValue(current, part, null, true, shouldIgnoreCase);
+		if (!handled.exists) return handled;
+		current = handled.value;
+	}
+	return {
+		exists: true,
+		value: current
+	};
+}
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
 	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
@@ -1292,23 +1362,29 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return data[key];
+		if (get) return {
+			exists: key in data,
+			value: data[key]
+		};
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
+	if (get) return {
+		exists: false,
+		value: void 0
+	};
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
 const EXPRESSION_NESTED = /\.|\[\w+\]/;
 function getValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return;
-	const shouldIgnoreCase = ignoreCase === true;
-	const paths = getPaths(path, shouldIgnoreCase);
-	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
-	const { length } = paths;
-	let index = 0;
-	let value = data;
-	while (index < length && value != null) value = handleValue(value, paths[index++], null, true, shouldIgnoreCase);
-	return value;
+	return getNestedValue(data, path, ignoreCase === true).value;
+}
+function hasValue(data, path, ignoreCase) {
+	return getNestedValue(data, path, ignoreCase === true).exists;
+}
+hasValue.get = getWithHasValue;
+function getWithHasValue(data, path, ignoreCase) {
+	return getNestedValue(data, path, ignoreCase === true);
 }
 function setValue(data, path, value, ignoreCase) {
 	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
@@ -1327,7 +1403,7 @@ function setValue(data, path, value, ignoreCase) {
 			handleValue(target, currentPath, value, false, shouldIgnoreCase);
 			break;
 		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase);
+		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
 			if (EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number.parseInt(nextPath, 10) + 1 }, () => void 0);
@@ -2796,15 +2872,6 @@ function isEmpty(value) {
 	return true;
 }
 /**
-* Is the value an instance of the constructor?
-* @param constructor Class constructor
-* @param value Value to check
-* @returns `true` if the value is an instance of the constructor, otherwise `false`
-*/
-function isInstanceOf(constructor, value) {
-	return isConstructor(constructor) && value instanceof constructor;
-}
-/**
 * Is the value not `undefined` or `null`?
 * @param value Value to check
 * @returns `true` if the value is not `undefined` or `null`, otherwise `false`
@@ -3010,12 +3077,12 @@ function floor(value, decimals) {
 function median(array, key) {
 	let length = Array.isArray(array) ? array.length : 0;
 	if (!Array.isArray(array) || length === 0) return NaN;
-	if (length === 1) return isNumber(array[0]) ? array[0] : NaN;
 	let values = array;
 	const callback = getAggregateCallback(key);
 	if (callback != null) values = array.map((item, index) => callback(item, index, array));
 	const numbers = values.filter(isNumber).sort((first, second) => first - second);
 	length = numbers.length;
+	if (length === 1) return numbers[0];
 	if (length % 2 === 0) {
 		const first = length / 2 - 1;
 		const second = length / 2;
@@ -3772,4 +3839,4 @@ var SizedSet = class extends Set {
 		}
 	}
 };
-export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };

package/dist/function/assert.js

@@ -1,19 +1,59 @@
+/**
+* Asserts that a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+*/
 function assert(condition, message, error) {
 	if (!condition()) throw new (error ?? Error)(message);
 }
-assert.condition = (condition, message, error) => {
+assert.condition = assertCondition;
+assert.defined = assertDefined;
+assert.instanceOf = assertInstanceOf;
+assert.is = assertIs;
+/**
+* Creates an asserter that asserts a condition is true, throwing an error if it is not
+* @param condition Condition to assert
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertCondition(condition, message, error) {
 	return (value) => {
 		assert(() => condition(value), message, error);
 	};
-};
-assert.instanceOf = (constructor, message, error) => {
+}
+/**
+* Asserts that a value is defined throwing an error if it is not
+* @param value Value to assert
+* @param message Error message
+*/
+function assertDefined(value, message) {
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
+}
+/**
+* Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
+* @param constructor Constructor to check against
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertInstanceOf(constructor, message, error) {
 	return (value) => {
 		assert(() => value instanceof constructor, message, error);
 	};
-};
-assert.is = (condition, message, error) => {
+}
+/**
+* Creates an asserter that asserts a value is of a specific type, throwing an error if it is not
+* @param condition Type guard function to check the value
+* @param message Error message
+* @param error Error constructor
+* @returns Asserter
+*/
+function assertIs(condition, message, error) {
 	return (value) => {
 		assert(() => condition(value), message, error);
 	};
-};
+}
+var MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 export { assert };

package/dist/index.js

@@ -3,7 +3,7 @@ import { filter } from "./array/filter.js";
 import { find } from "./array/find.js";
 import { flatten } from "./array/flatten.js";
 import { range, times } from "./array/from.js";
-import { isArrayOrPlainObject, isConstructor, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.js";
+import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.js";
 import { getArray } from "./array/get.js";
 import { groupBy } from "./array/group-by.js";
 import { indexOf } from "./array/index-of.js";
@@ -44,6 +44,7 @@ import { isError, isOk, isResult } from "./internal/result.js";
 import { flow, pipe } from "./function/work.js";
 import { equal } from "./internal/value/equal.js";
 import { getValue } from "./internal/value/get.js";
+import { hasValue } from "./internal/value/has.js";
 import { setValue } from "./internal/value/set.js";
 import { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase } from "./string/case.js";
 import { endsWith, includes, startsWith } from "./string/match.js";
@@ -56,7 +57,7 @@ import { omit } from "./value/omit.js";
 import { pick } from "./value/pick.js";
 import { smush } from "./value/smush.js";
 import { unsmush } from "./value/unsmush.js";
-import { isEmpty, isInstanceOf, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumerical, isObject, isPrimitive } from "./is.js";
+import { isEmpty, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumerical, isObject, isPrimitive } from "./is.js";
 import { logger } from "./logger.js";
 import { average, ceil, count, floor, median, min, round, sum } from "./math.js";
 import { CancelablePromise, PromiseTimeoutError } from "./promise/models.js";
@@ -71,4 +72,4 @@ import { QueueError, queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, getRandomItem, getRandomItems } from "./random.js";
 import { attempt } from "./result/index.js";
 import { SizedSet } from "./sized/set.js";
-export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/is.js

@@ -15,6 +15,15 @@ function isConstructor(value) {
 	return typeof value === "function" && value.prototype?.constructor === value;
 }
 /**
+* Is the value an instance of the constructor?
+* @param constructor Class constructor
+* @param value Value to check
+* @returns `true` if the value is an instance of the constructor, otherwise `false`
+*/
+function isInstanceOf(constructor, value) {
+	return isConstructor(constructor) && value instanceof constructor;
+}
+/**
 * Is the value a key?
 * @param value Value to check
 * @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
@@ -63,4 +72,4 @@ function isTypedArray(value) {
 	return TYPED_ARRAYS.has(value?.constructor);
 }
 var TYPED_ARRAYS;
-export { isArrayOrPlainObject, isConstructor, isKey, isNumber, isPlainObject, isTypedArray };
+export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray };

package/dist/internal/value/get.js

@@ -1,13 +1,5 @@
-import { getPaths, handleValue } from "./misc.js";
+import { getNestedValue } from "./misc.js";
 function getValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return;
-	const shouldIgnoreCase = ignoreCase === true;
-	const paths = getPaths(path, shouldIgnoreCase);
-	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
-	const { length } = paths;
-	let index = 0;
-	let value = data;
-	while (index < length && value != null) value = handleValue(value, paths[index++], null, true, shouldIgnoreCase);
-	return value;
+	return getNestedValue(data, path, ignoreCase === true).value;
 }
 export { getValue };

package/dist/internal/value/has.js

@@ -0,0 +1,9 @@
+import { getNestedValue } from "./misc.js";
+function hasValue(data, path, ignoreCase) {
+	return getNestedValue(data, path, ignoreCase === true).exists;
+}
+hasValue.get = getWithHasValue;
+function getWithHasValue(data, path, ignoreCase) {
+	return getNestedValue(data, path, ignoreCase === true);
+}
+export { hasValue };

package/dist/internal/value/misc.js

@@ -4,6 +4,27 @@ function findKey(needle, haystack) {
 	const index = keys.map((key) => key.toLowerCase()).indexOf(needle.toLowerCase());
 	return index > -1 ? keys[index] : needle;
 }
+function getNestedValue(data, path, ignoreCase) {
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return {
+		exists: false,
+		value: void 0
+	};
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
+	const { length } = paths;
+	let current = data;
+	for (let index = 0; index < length; index += 1) {
+		const part = paths[index];
+		const handled = handleValue(current, part, null, true, shouldIgnoreCase);
+		if (!handled.exists) return handled;
+		current = handled.value;
+	}
+	return {
+		exists: true,
+		value: current
+	};
+}
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
 	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
@@ -12,11 +33,18 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return data[key];
+		if (get) return {
+			exists: key in data,
+			value: data[key]
+		};
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
+	if (get) return {
+		exists: false,
+		value: void 0
+	};
 }
 var EXPRESSION_BRACKET = /\[(\w+)\]/g;
 var EXPRESSION_DOTS = /^\.|\.$/g;
 var EXPRESSION_NESTED = /\.|\[\w+\]/;
-export { getPaths, handleValue };
+export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/set.js

@@ -16,7 +16,7 @@ function setValue(data, path, value, ignoreCase) {
 			handleValue(target, currentPath, value, false, shouldIgnoreCase);
 			break;
 		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase);
+		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
 			if (EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number.parseInt(nextPath, 10) + 1 }, () => void 0);

package/dist/is.js

@@ -1,4 +1,4 @@
-import { isArrayOrPlainObject, isConstructor, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.js";
+import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray } from "./internal/is.js";
 import { getArray } from "./array/get.js";
 import { getString } from "./internal/string.js";
 /**
@@ -15,15 +15,6 @@ function isEmpty(value) {
 	return true;
 }
 /**
-* Is the value an instance of the constructor?
-* @param constructor Class constructor
-* @param value Value to check
-* @returns `true` if the value is an instance of the constructor, otherwise `false`
-*/
-function isInstanceOf(constructor, value) {
-	return isConstructor(constructor) && value instanceof constructor;
-}
-/**
 * Is the value not `undefined` or `null`?
 * @param value Value to check
 * @returns `true` if the value is not `undefined` or `null`, otherwise `false`

package/dist/math.js

@@ -37,12 +37,12 @@ function floor(value, decimals) {
 function median(array, key) {
 	let length = Array.isArray(array) ? array.length : 0;
 	if (!Array.isArray(array) || length === 0) return NaN;
-	if (length === 1) return isNumber(array[0]) ? array[0] : NaN;
 	let values = array;
 	const callback = getAggregateCallback(key);
 	if (callback != null) values = array.map((item, index) => callback(item, index, array));
 	const numbers = values.filter(isNumber).sort((first, second) => first - second);
 	length = numbers.length;
+	if (length === 1) return numbers[0];
 	if (length % 2 === 0) {
 		const first = length / 2 - 1;
 		const second = length / 2;

package/dist/value/{get-set.js → handle.js}

@@ -1,3 +1,4 @@
 import { getValue } from "../internal/value/get.js";
+import { hasValue } from "../internal/value/has.js";
 import { setValue } from "../internal/value/set.js";
-export { getValue, setValue };
+export { getValue, hasValue, setValue };

package/package.json

@@ -145,9 +145,9 @@
 			"types": "./types/internal/value/equal.d.ts",
 			"default": "./dist/internal/value/equal.js"
 		},
-		"./value/get-set": {
-			"types": "./types/value/get-set.d.ts",
-			"default": "./dist/value/get-set.js"
+		"./value/handle": {
+			"types": "./types/value/handle.d.ts",
+			"default": "./dist/value/handle.js"
 		},
 		"./value/merge": {
 			"types": "./types/value/merge.d.ts",
@@ -184,5 +184,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.154.0"
+	"version": "0.155.0"
 }

package/src/function/assert.ts

@@ -47,7 +47,7 @@ function assertCondition<Value>(
 }
 
 /**
- * Asserts that a value is defined _(not `null` or `undefined`)_, throwing an error if it is not
+ * Asserts that a value is defined throwing an error if it is not
  * @param value Value to assert
  * @param message Error message
  */
@@ -55,7 +55,7 @@ function assertDefined<Value>(
 	value: unknown,
 	message?: string,
 ): asserts value is Exclude<Value, null | undefined> {
-	assert(() => value != null, message ?? MESSAGE_DEFINED);
+	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED);
 }
 
 /**
@@ -96,6 +96,6 @@ function assertIs<Value>(
 
 // #region Variables
 
-const MESSAGE_DEFINED = 'Expected value to be defined';
+const MESSAGE_VALUE_DEFINED = 'Expected value to be defined';
 
 // #endregion

package/src/index.ts

@@ -13,6 +13,7 @@ export * from './internal/string';
 export * from './internal/value/compare';
 export * from './internal/value/equal';
 export * from './internal/value/get';
+export * from './internal/value/has';
 export * from './internal/value/set';
 
 export * from './string/case';

package/src/internal/is.ts

@@ -20,6 +20,19 @@ export function isConstructor(value: unknown): value is Constructor {
 	return typeof value === 'function' && value.prototype?.constructor === value;
 }
 
+/**
+ * Is the value an instance of the constructor?
+ * @param constructor Class constructor
+ * @param value Value to check
+ * @returns `true` if the value is an instance of the constructor, otherwise `false`
+ */
+export function isInstanceOf<Instance>(
+	constructor: Constructor<Instance>,
+	value: unknown,
+): value is Instance {
+	return isConstructor(constructor) && value instanceof constructor;
+}
+
 /**
  * Is the value a key?
  * @param value Value to check

package/src/internal/value/get.ts

@@ -1,5 +1,5 @@
 import type {NestedKeys, NestedValue, PlainObject, ToString} from '../../models';
-import {getPaths, handleValue} from './misc';
+import {getNestedValue} from './misc';
 
 // #region Functions
 
@@ -28,32 +28,7 @@ export function getValue<Data extends PlainObject>(
 ): unknown;
 
 export function getValue(data: PlainObject, path: string, ignoreCase?: boolean): unknown {
-	if (
-		typeof data !== 'object' ||
-		data === null ||
-		typeof path !== 'string' ||
-		path.trim().length === 0
-	) {
-		return;
-	}
-
-	const shouldIgnoreCase = ignoreCase === true;
-	const paths = getPaths(path, shouldIgnoreCase);
-
-	if (typeof paths === 'string') {
-		return handleValue(data, paths, null, true, shouldIgnoreCase);
-	}
-
-	const {length} = paths;
-
-	let index = 0;
-	let value: PlainObject = data;
-
-	while (index < length && value != null) {
-		value = handleValue(value, paths[index++], null, true, shouldIgnoreCase) as PlainObject;
-	}
-
-	return value as never;
+	return getNestedValue(data, path, ignoreCase === true).value;
 }
 
 // #endregion

package/src/internal/value/has.ts

@@ -0,0 +1,75 @@
+import type {NestedKeys, NestedValue, PlainObject, ToString} from '../../models';
+import {getNestedValue} from './misc';
+
+// #region Types
+
+export type HasValue<Value> = {
+	exists: boolean;
+	value: Value;
+};
+
+// #endregion
+
+// #region Functions
+
+/**
+ * Check if a nested property is defined in an object
+ * @param data Object to check in
+ * @param path Path for property
+ * @return `true` if the property exists, `false` otherwise
+ */
+export function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(
+	data: Data,
+	path: Path,
+): boolean;
+
+/**
+ * Check if a nested property is defined in an object
+ * @param data Object to check in
+ * @param path Path for property
+ * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @return `true` if the property exists, `false` otherwise
+ */
+export function hasValue<Data extends PlainObject>(
+	data: Data,
+	path: string,
+	ignoreCase?: boolean,
+): boolean;
+
+export function hasValue(data: PlainObject, path: string, ignoreCase?: boolean): boolean {
+	return getNestedValue(data, path, ignoreCase === true).exists;
+}
+
+hasValue.get = getWithHasValue;
+
+/**
+ * Check if a nested property is defined in an object, and get its value if it is
+ * @param data Object to check in
+ * @param path Path for property
+ * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @return Result object
+ */
+function getWithHasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(
+	data: Data,
+	path: Path,
+	ignoreCase?: boolean,
+): HasValue<NestedValue<Data, ToString<Path>>>;
+
+/**
+ * Check if a nested property is defined in an object, and get its value if it is
+ * @param data Object to check in
+ * @param path Path for property
+ * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @return Result object
+ */
+function getWithHasValue<Data extends PlainObject>(
+	data: Data,
+	path: string,
+	ignoreCase?: boolean,
+): HasValue<unknown>;
+
+function getWithHasValue(data: PlainObject, path: string, ignoreCase?: boolean): HasValue<unknown> {
+	return getNestedValue(data, path, ignoreCase === true);
+}
+
+// #endregion

package/src/internal/value/misc.ts

@@ -1,9 +1,9 @@
-import type {ArrayOrPlainObject, PlainObject} from '../../models';
+import type {PlainObject} from '../../models';
 import {ignoreKey} from '../string';
 
 // #region Functions
 
-function findKey(needle: string, haystack: ArrayOrPlainObject): string {
+export function findKey(needle: string, haystack: object): string {
 	const keys = Object.keys(haystack);
 	const normalized = keys.map(key => key.toLowerCase());
 	const index = normalized.indexOf(needle.toLowerCase());
@@ -11,6 +11,46 @@ function findKey(needle: string, haystack: ArrayOrPlainObject): string {
 	return index > -1 ? keys[index] : needle;
 }
 
+export function getNestedValue(
+	data: object,
+	path: string,
+	ignoreCase: boolean,
+): {exists: boolean; value: unknown} {
+	if (
+		typeof data !== 'object' ||
+		data === null ||
+		typeof path !== 'string' ||
+		path.trim().length === 0
+	) {
+		return {exists: false, value: undefined};
+	}
+
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+
+	if (typeof paths === 'string') {
+		return handleValue(data, paths, null, true, shouldIgnoreCase);
+	}
+
+	const {length} = paths;
+
+	let current = data;
+
+	for (let index = 0; index < length; index += 1) {
+		const part = paths[index];
+
+		const handled = handleValue(current, part, null, true, shouldIgnoreCase);
+
+		if (!handled.exists) {
+			return handled;
+		}
+
+		current = handled.value as object;
+	}
+
+	return {exists: true, value: current};
+}
+
 export function getPaths(path: string, lowercase: boolean): string | string[] {
 	const normalized = lowercase ? path.toLowerCase() : path;
 
@@ -22,21 +62,41 @@ export function getPaths(path: string, lowercase: boolean): string | string[] {
 }
 
 export function handleValue(
-	data: ArrayOrPlainObject,
+	data: object,
+	path: string,
+	value: unknown,
+	get: true,
+	ignoreCase: boolean,
+): {exists: boolean; value: unknown};
+
+export function handleValue(
+	data: object,
+	path: string,
+	value: unknown,
+	get: false,
+	ignoreCase: boolean,
+): void;
+
+export function handleValue(
+	data: object,
 	path: string,
 	value: unknown,
 	get: boolean,
 	ignoreCase: boolean,
-): unknown {
+): {exists: boolean; value: unknown} | void {
 	if (typeof data === 'object' && data !== null && !ignoreKey(path)) {
 		const key = ignoreCase ? findKey(path, data) : path;
 
 		if (get) {
-			return data[key as never];
+			return {exists: key in data, value: data[key as never]};
 		}
 
 		(data as PlainObject)[key] = typeof value === 'function' ? value(data[key as never]) : value;
 	}
+
+	if (get) {
+		return {exists: false, value: undefined};
+	}
 }
 
 // #endregion

package/src/internal/value/set.ts

@@ -44,12 +44,12 @@ export function setValue<Data extends PlainObject>(
 	ignoreCase?: boolean,
 ): Data;
 
-export function setValue<Data extends PlainObject>(
-	data: Data,
+export function setValue(
+	data: object,
 	path: string,
 	value: unknown,
 	ignoreCase?: boolean,
-): Data {
+): object {
 	if (
 		typeof data !== 'object' ||
 		data === null ||
@@ -71,7 +71,7 @@ export function setValue<Data extends PlainObject>(
 	const {length} = paths;
 	const lastIndex = length - 1;
 
-	let target: PlainObject = data;
+	let target = data;
 
 	for (let index = 0; index < length; index += 1) {
 		const currentPath = paths[index];
@@ -82,7 +82,7 @@ export function setValue<Data extends PlainObject>(
 			break;
 		}
 
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase);
+		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 
 		if (typeof next !== 'object' || next === null) {
 			const nextPath = paths[index + 1];
@@ -96,7 +96,7 @@ export function setValue<Data extends PlainObject>(
 			(target as PlainObject)[currentPath] = next;
 		}
 
-		target = next as PlainObject;
+		target = next as object;
 	}
 
 	return data;

package/src/is.ts

@@ -1,7 +1,7 @@
 import {getArray} from './array/get';
-import {isConstructor, isNumber} from './internal/is';
+import {isNumber} from './internal/is';
 import {getString} from './internal/string';
-import type {Constructor, Primitive} from './models';
+import type {Primitive} from './models';
 
 // #region Functions
 
@@ -31,19 +31,6 @@ export function isEmpty(value: unknown): boolean {
 	return true;
 }
 
-/**
- * Is the value an instance of the constructor?
- * @param constructor Class constructor
- * @param value Value to check
- * @returns `true` if the value is an instance of the constructor, otherwise `false`
- */
-export function isInstanceOf<Instance>(
-	constructor: Constructor<Instance>,
-	value: unknown,
-): value is Instance {
-	return isConstructor(constructor) && value instanceof constructor;
-}
-
 /**
  * Is the value not `undefined` or `null`?
  * @param value Value to check
@@ -125,6 +112,7 @@ const EXPRESSION_WHITESPACE = /^\s*$/;
 export {
 	isArrayOrPlainObject,
 	isConstructor,
+	isInstanceOf,
 	isKey,
 	isNumber,
 	isPlainObject,

package/src/value/{get-set.ts → handle.ts}

@@ -1,2 +1,3 @@
 export {getValue} from '../internal/value/get';
+export {hasValue} from '../internal/value/has';
 export {setValue} from '../internal/value/set';

package/types/function/assert.d.ts

@@ -1,8 +1,46 @@
 import type { Constructor } from '../models';
 export type Asserter<Value> = (value: unknown) => asserts value is Value;
+/**
+ * Asserts that a condition is true, throwing an error if it is not
+ * @param condition Condition to assert
+ * @param message Error message
+ * @param error Error constructor
+ */
 export declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
 export declare namespace assert {
-    var condition: <Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor) => Asserter<Value>;
-    var instanceOf: <Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor) => Asserter<Value>;
-    var is: <Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor) => Asserter<Value>;
+    var condition: typeof assertCondition;
+    var defined: typeof assertDefined;
+    var instanceOf: typeof assertInstanceOf;
+    var is: typeof assertIs;
 }
+/**
+ * Creates an asserter that asserts a condition is true, throwing an error if it is not
+ * @param condition Condition to assert
+ * @param message Error message
+ * @param error Error constructor
+ * @returns Asserter
+ */
+declare function assertCondition<Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Asserts that a value is defined throwing an error if it is not
+ * @param value Value to assert
+ * @param message Error message
+ */
+declare function assertDefined<Value>(value: unknown, message?: string): asserts value is Exclude<Value, null | undefined>;
+/**
+ * Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
+ * @param constructor Constructor to check against
+ * @param message Error message
+ * @param error Error constructor
+ * @returns Asserter
+ */
+declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Creates an asserter that asserts a value is of a specific type, throwing an error if it is not
+ * @param condition Type guard function to check the value
+ * @param message Error message
+ * @param error Error constructor
+ * @returns Asserter
+ */
+declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
+export {};

package/types/index.d.ts

@@ -11,6 +11,7 @@ export * from './internal/string';
 export * from './internal/value/compare';
 export * from './internal/value/equal';
 export * from './internal/value/get';
+export * from './internal/value/has';
 export * from './internal/value/set';
 export * from './string/case';
 export * from './string/match';

package/types/internal/is.d.ts

@@ -11,6 +11,13 @@ export declare function isArrayOrPlainObject(value: unknown): value is ArrayOrPl
  * @returns `true` if the value is a constructor function, otherwise `false`
  */
 export declare function isConstructor(value: unknown): value is Constructor;
+/**
+ * Is the value an instance of the constructor?
+ * @param constructor Class constructor
+ * @param value Value to check
+ * @returns `true` if the value is an instance of the constructor, otherwise `false`
+ */
+export declare function isInstanceOf<Instance>(constructor: Constructor<Instance>, value: unknown): value is Instance;
 /**
  * Is the value a key?
  * @param value Value to check

package/types/internal/value/has.d.ts

@@ -0,0 +1,40 @@
+import type { NestedKeys, NestedValue, PlainObject, ToString } from '../../models';
+export type HasValue<Value> = {
+    exists: boolean;
+    value: Value;
+};
+/**
+ * Check if a nested property is defined in an object
+ * @param data Object to check in
+ * @param path Path for property
+ * @return `true` if the property exists, `false` otherwise
+ */
+export declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): boolean;
+/**
+ * Check if a nested property is defined in an object
+ * @param data Object to check in
+ * @param path Path for property
+ * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @return `true` if the property exists, `false` otherwise
+ */
+export declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
+export declare namespace hasValue {
+    var get: typeof getWithHasValue;
+}
+/**
+ * Check if a nested property is defined in an object, and get its value if it is
+ * @param data Object to check in
+ * @param path Path for property
+ * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @return Result object
+ */
+declare function getWithHasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): HasValue<NestedValue<Data, ToString<Path>>>;
+/**
+ * Check if a nested property is defined in an object, and get its value if it is
+ * @param data Object to check in
+ * @param path Path for property
+ * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @return Result object
+ */
+declare function getWithHasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): HasValue<unknown>;
+export {};

package/types/internal/value/misc.d.ts

@@ -1,3 +1,11 @@
-import type { ArrayOrPlainObject } from '../../models';
+export declare function findKey(needle: string, haystack: object): string;
+export declare function getNestedValue(data: object, path: string, ignoreCase: boolean): {
+    exists: boolean;
+    value: unknown;
+};
 export declare function getPaths(path: string, lowercase: boolean): string | string[];
-export declare function handleValue(data: ArrayOrPlainObject, path: string, value: unknown, get: boolean, ignoreCase: boolean): unknown;
+export declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): {
+    exists: boolean;
+    value: unknown;
+};
+export declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;

package/types/is.d.ts

@@ -1,17 +1,10 @@
-import type { Constructor, Primitive } from './models';
+import type { Primitive } from './models';
 /**
  * Is the value empty, or only containing `null` or `undefined` values?
  * @param value Value to check
  * @returns `true` if the value is considered empty, otherwise `false`
  */
 export declare function isEmpty(value: unknown): boolean;
-/**
- * Is the value an instance of the constructor?
- * @param constructor Class constructor
- * @param value Value to check
- * @returns `true` if the value is an instance of the constructor, otherwise `false`
- */
-export declare function isInstanceOf<Instance>(constructor: Constructor<Instance>, value: unknown): value is Instance;
 /**
  * Is the value not `undefined` or `null`?
  * @param value Value to check
@@ -54,4 +47,4 @@ export declare function isObject(value: unknown): value is object;
  * @returns `true` if the value matches, otherwise `false`
  */
 export declare function isPrimitive(value: unknown): value is Primitive;
-export { isArrayOrPlainObject, isConstructor, isKey, isNumber, isPlainObject, isTypedArray, } from './internal/is';
+export { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNumber, isPlainObject, isTypedArray, } from './internal/is';

package/types/value/{get-set.d.ts → handle.d.ts}

@@ -1,2 +1,3 @@
 export { getValue } from '../internal/value/get';
+export { hasValue } from '../internal/value/has';
 export { setValue } from '../internal/value/set';