@oscarpalmer/atoms 0.193.0 → 0.194.0

package/dist/internal/abort.d.mts

@@ -0,0 +1,10 @@
+import { GenericCallback } from "../models.mjs";
+//#region src/internal/abort.d.ts
+type Aborter = {
+  callback: GenericCallback;
+  signal: AbortSignal;
+  cancel: () => void;
+};
+declare function createAborter(value: unknown, onAbort: () => void): Aborter | undefined;
+//#endregion
+export { Aborter, createAborter };

package/dist/internal/abort.mjs

@@ -0,0 +1,14 @@
+//#region src/internal/abort.ts
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
+	return {
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
+	};
+}
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
+//#endregion
+export { createAborter };

package/dist/internal/array/chunk.mjs

@@ -15,7 +15,7 @@ function chunk(array, size) {
 	if (!Array.isArray(array)) return [];
 	if (array.length === 0) return [];
 	const { length } = array;
-	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
+	const actualSize = typeof size === "number" && size > 0 && size <= CHUNK_MAX_SIZE ? size : CHUNK_MAX_SIZE;
 	if (length <= actualSize) return [array];
 	const chunks = [];
 	let index = 0;
@@ -25,6 +25,6 @@ function chunk(array, size) {
 	}
 	return chunks;
 }
-const MAX_SIZE = 5e3;
+const CHUNK_MAX_SIZE = 5e3;
 //#endregion
 export { chunk };

package/dist/internal/array/find.mjs

@@ -40,7 +40,7 @@ function findValues(type, array, parameters, mapper) {
 	const { length } = array;
 	const { bool, key, value } = getFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
@@ -77,6 +77,6 @@ const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
 const FIND_VALUES_ALL = "all";
 const FIND_VALUES_UNIQUE = "unique";
-const UNIQUE_THRESHOLD = 100;
+const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
 export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, findAbsoluteValueOrDefault, findValue, findValues, getFindParameters };

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

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

package/dist/internal/array/sets.mjs

@@ -2,9 +2,9 @@ import { getArrayCallback } from "./callbacks.mjs";
 //#region src/internal/array/sets.ts
 function compareSets(type, first, second, key) {
 	if (!Array.isArray(first)) return [];
-	const isDifference = type === COMPARE_SETS_DIFFERENCE;
-	const isIntersection = type === COMPARE_SETS_INTERSECTION;
-	const isUnion = type === COMPARE_SETS_UNION;
+	const isDifference = type === SETS_COMPARE_DIFFERENCE;
+	const isIntersection = type === SETS_COMPARE_INTERSECTION;
+	const isUnion = type === SETS_COMPARE_UNION;
 	if (first.length === 0) return isDifference ? first.slice() : isIntersection ? [] : second.slice();
 	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : first.slice();
 	const callback = getArrayCallback(key);
@@ -25,8 +25,8 @@ function compareSets(type, first, second, key) {
 	}
 	return result;
 }
-const COMPARE_SETS_DIFFERENCE = "difference";
-const COMPARE_SETS_INTERSECTION = "intersection";
-const COMPARE_SETS_UNION = "union";
+const SETS_COMPARE_DIFFERENCE = "difference";
+const SETS_COMPARE_INTERSECTION = "intersection";
+const SETS_COMPARE_UNION = "union";
 //#endregion
-export { COMPARE_SETS_DIFFERENCE, COMPARE_SETS_INTERSECTION, COMPARE_SETS_UNION, compareSets };
+export { SETS_COMPARE_DIFFERENCE, SETS_COMPARE_INTERSECTION, SETS_COMPARE_UNION, compareSets };

package/dist/internal/function/timer.mjs

@@ -1,9 +1,16 @@
 //#region src/internal/function/timer.ts
 function getAsyncTimer(type, callback, time) {
+	function cancel() {
+		clearTimer(id);
+		if (last != null && !last.running) {
+			last.reject();
+			last = void 0;
+		}
+	}
 	async function run(item) {
 		const now = performance.now();
 		start ??= now;
-		if (interval === 0 || now - start >= interval - OFFSET) {
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
 			start = throttle ? now : void 0;
 			item.running = true;
 			try {
@@ -23,7 +30,7 @@ function getAsyncTimer(type, callback, time) {
 	let last;
 	let start;
 	const timer = (...parameters) => {
-		timer.cancel();
+		cancel();
 		const next = {
 			parameters,
 			running: false
@@ -34,25 +41,23 @@ function getAsyncTimer(type, callback, time) {
 		});
 		last = next;
 		if (throttle) run(next);
-		else id = startTimer(() => {
-			run(next);
-		});
+		else id = startTimer(() => run(next));
 		return next.promise;
 	};
-	timer.cancel = () => {
-		clearTimer(id);
-		if (last != null && !last.running) last.reject();
-	};
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
 	return timer;
 }
 function getInterval(value) {
 	return typeof value === "number" && value > 0 ? value : 0;
 }
 function getTimer(type, callback, time) {
+	function cancel() {
+		clearTimer(id);
+	}
 	function run() {
 		const now = performance.now();
 		start ??= now;
-		if (interval === 0 || now - start >= interval - OFFSET) {
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
 			start = throttle ? now : void 0;
 			callback(...args);
 		} else id = startTimer(run);
@@ -63,18 +68,17 @@ function getTimer(type, callback, time) {
 	let id;
 	let start;
 	const timer = (...parameters) => {
-		timer.cancel();
+		cancel();
 		args = parameters;
 		if (throttle) run();
 		else id = startTimer(run);
 	};
-	timer.cancel = () => {
-		clearTimer(id);
-	};
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
 	return timer;
 }
-const OFFSET = 5;
+const TIMER_CANCEL = "cancel";
 const TIMER_DEBOUNCE = "debounce";
+const TIMER_OFFSET = 5;
 const TIMER_THROTTLE = "throttle";
 const TIMER_WAIT = "wait";
 // istanbul ignore next

package/dist/internal/number.mjs

@@ -59,17 +59,17 @@ function getNumber(value) {
 	if (typeof parsed !== "string") return getNumber(parsed);
 	const trimmed = parsed.trim();
 	if (trimmed.length === 0) return NaN;
-	if (EXPRESSION_ZEROISH.test(parsed)) return 0;
-	const isBinary = EXPRESSION_BINARY.test(trimmed);
-	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
+	if (NUMBER_EXPRESSION_ZEROISH.test(parsed)) return 0;
+	const isBinary = NUMBER_EXPRESSION_BINARY.test(trimmed);
+	if (isBinary || NUMBER_EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : NUMBER_OCTAL_VALUE);
 	return Number(trimmed);
 }
 function getNumberOrDefault(value, defaultValue, minimum) {
 	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? Math.floor(value) : defaultValue;
 }
-const EXPRESSION_BINARY = /^0b[01]+$/i;
-const EXPRESSION_OCTAL = /^0o[0-7]+$/i;
-const EXPRESSION_ZEROISH = /^\s*0+\s*$/;
-const OCTAL_VALUE = 8;
+const NUMBER_EXPRESSION_BINARY = /^0b[01]+$/i;
+const NUMBER_EXPRESSION_OCTAL = /^0o[0-7]+$/i;
+const NUMBER_EXPRESSION_ZEROISH = /^\s*0+\s*$/;
+const NUMBER_OCTAL_VALUE = 8;
 //#endregion
 export { between, clamp, getNumber, getNumberOrDefault };

package/dist/internal/result.mjs

@@ -17,9 +17,9 @@ function isResult(value) {
 }
 function isResultValue(value, okValue) {
 	if (isNonPlainObject(value)) return false;
-	return value.ok === okValue && (okValue ? PROPERTY_VALUE : PROPERTY_ERROR) in value;
+	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
 }
-const PROPERTY_ERROR = "error";
-const PROPERTY_VALUE = "value";
+const RESULT_PROPERTY_ERROR = "error";
+const RESULT_PROPERTY_VALUE = "value";
 //#endregion
 export { isError, isOk, isResult };

package/dist/internal/sized.mjs

@@ -3,10 +3,10 @@ import { clamp } from "./number.mjs";
 function getSizedMaximum(first, second) {
 	let actual;
 	if (typeof first === "number") actual = first;
-	else actual = typeof second === "number" ? second : MAXIMUM_DEFAULT;
-	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
+	else actual = typeof second === "number" ? second : SIZED_MAXIMUM_DEFAULT;
+	return clamp(actual, 1, SIZED_MAXIMUM_ABSOLUTE);
 }
-const MAXIMUM_ABSOLUTE = 16777216;
-const MAXIMUM_DEFAULT = 1048576;
+const SIZED_MAXIMUM_ABSOLUTE = 16777216;
+const SIZED_MAXIMUM_DEFAULT = 1048576;
 //#endregion
 export { getSizedMaximum };

package/dist/internal/string.mjs

@@ -25,7 +25,7 @@ function getString(value) {
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 function ignoreKey(key) {
-	return EXPRESSION_IGNORED.test(key);
+	return STRING_EXPRESSION_IGNORED.test(key);
 }
 function interpolate(strings, values) {
 	const { length } = strings;
@@ -76,9 +76,9 @@ function tryEncode(value) {
 * @returns Array of words found in the string
 */
 function words(value) {
-	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
+	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
 }
-const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
+const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
 export { getString, ignoreKey, interpolate, join, tryDecode, tryEncode, words };

package/dist/internal/subscription.d.mts

@@ -12,16 +12,33 @@ type Subscription = {
 };
 type SubscriptionParameters = {
   isActive?: () => boolean;
-  key?: Key;
-  property: SubscriptionProperty;
-  subscriptions: Subscriptions;
+  key?: unknown;
+  signal?: AbortSignal;
   value: unknown;
 };
+/**
+ * Property information for subscription identification
+ */
 type SubscriptionProperty = {
+  /**
+   * Name of the property used to identify a subscription
+   */
   key: string;
-  value: unknown;
+  /**
+   * Value of the property used to identify a subscription _(defaults to `subscription`)_
+   */
+  value?: unknown;
 };
 type Subscriptions<Value = unknown> = {
+  state: SubscriptionsState<Value>;
+  clear: () => void;
+  create: (parameters: SubscriptionParameters) => [Subscription, boolean];
+};
+type SubscriptionsParameters = {
+  keys?: Set<Key>;
+  property: SubscriptionProperty;
+};
+type SubscriptionsState<Value = unknown> = {
   items: SubscriptionsItems;
   keys?: Set<Key>;
   values: SubscriptionsValues<Value>;
@@ -38,9 +55,7 @@ type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
   keyed?: Map<Key, Map<MapKey, MapValue>>;
 };
-declare function clearSubscriptions(store: Subscriptions): void;
-declare function getSubscription(parameters: SubscriptionParameters): Subscription;
-declare function getSubscriptions<Value = unknown>(keys?: Set<Key>): Subscriptions<Value>;
+declare function createSubscriptions<Value = unknown>(parameters: SubscriptionsParameters): Subscriptions<Value>;
 /**
  * Is the value a subscription?
  *
@@ -48,5 +63,6 @@ declare function getSubscriptions<Value = unknown>(keys?: Set<Key>): Subscriptio
  * @returns `true` if the value is a subscription, otherwise `false`
  */
 declare function isSubscription(value: unknown): value is Subscription;
+declare const SUBSCRIPTION_NAME = "subscription";
 //#endregion
-export { Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, clearSubscriptions, getSubscription, getSubscriptions, isSubscription };
+export { SUBSCRIPTION_NAME, Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, createSubscriptions, isSubscription };

package/dist/internal/subscription.mjs

@@ -1,14 +1,16 @@
-import { isPlainObject } from "./is.mjs";
+import { isKey, isPlainObject } from "./is.mjs";
+import { createAborter } from "./abort.mjs";
 //#region src/internal/subscription.ts
-function addSubscription(subscription, state) {
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
+function addSubscription(subscriptions, subscription, state) {
+	const { key, value } = state.parameters;
+	const { items, values } = subscriptions.state;
+	if (!isKey(key)) {
 		items.any.add(subscription);
 		values.from.any.set(value, subscription);
 		values.to.any.set(subscription, value);
 		return;
 	}
+	/* istanbul ignore if */
 	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
  // istanbul ignore next
 	return;
@@ -35,41 +37,31 @@ function clearSubscriptions(store) {
 	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
 	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function getExistingSubscription(state) {
-	const { parameters } = state;
-	const { values } = parameters.subscriptions;
-	return parameters.key == null ? values.from.any.get(parameters.value) : values.from.keyed?.get(parameters.key)?.get(parameters.value);
-}
-function getSubscription(parameters) {
+function createSubscription(subscriptions, property, parameters) {
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
 	const state = {
 		parameters,
 		active: true
 	};
-	const existing = getExistingSubscription(state);
-	if (existing != null) return existing;
-	if (parameters.subscriptions.keys != null && parameters.key != null && !parameters.subscriptions.keys.has(parameters.key)) throw new Error();
-	const instance = { unsubscribe: () => {
-		removeSubscription(instance, state);
-	} };
+	const existing = getExistingSubscription(subscriptions, state);
+	if (existing != null) return [existing, true];
+	if (subscriptions.state.keys != null && isKey(parameters.key) && !subscriptions.state.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
+	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
+	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
 	Object.defineProperties(instance, {
-		[PROPERTY]: {
-			enumerable: false,
-			value: true
-		},
-		[parameters.property.key]: {
-			enumerable: false,
-			value: parameters.property.value
-		},
+		[SUBSCRIPTION_PROPERTY]: { value: true },
+		[property.key]: { value: property.value ?? "subscription" },
 		active: {
 			enumerable: true,
 			get: () => (parameters.isActive?.() ?? true) && state.active
 		}
 	});
-	addSubscription(instance, state);
-	return Object.freeze(instance);
+	addSubscription(subscriptions, instance, state);
+	return [Object.freeze(instance), false];
 }
-function getSubscriptions(keys) {
-	return {
+function createSubscriptions(parameters) {
+	const { keys, property } = parameters;
+	const state = {
 		keys,
 		items: {
 			any: /* @__PURE__ */ new Set(),
@@ -86,6 +78,17 @@ function getSubscriptions(keys) {
 			}
 		}
 	};
+	const instance = {
+		state,
+		clear: () => clearSubscriptions(state),
+		create: (parameters) => createSubscription(instance, property, parameters)
+	};
+	return instance;
+}
+function getExistingSubscription(subscriptions, state) {
+	const { parameters } = state;
+	const { values } = subscriptions.state;
+	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
 /**
 * Is the value a subscription?
@@ -94,7 +97,7 @@ function getSubscriptions(keys) {
 * @returns `true` if the value is a subscription, otherwise `false`
 */
 function isSubscription(value) {
-	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
+	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === true;
 }
 function removeFromStore(items, values, subscription, value, key) {
 	items.delete(subscription);
@@ -106,22 +109,32 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscription, state) {
+function removeSubscription(subscriptions, subscription, state) {
 	if (!state.active) return;
+	state.aborter = void 0;
 	state.active = false;
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
+	state.parameters.isActive = void 0;
+	state.parameters.signal = void 0;
+	const { key, value } = state.parameters;
+	const { items, values } = subscriptions.state;
+	if (!isKey(key)) {
 		removeFromStore(items.any, values, subscription, value);
 		return;
 	}
 	const keyed = items.keyed?.get(key);
+	/* istanbul ignore if */
 	if (items.keyed == null || keyed == null)
  // istanbul ignore next
 	return;
 	removeFromStore(keyed, values, subscription, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
-const PROPERTY = "$subscription";
+function unsubscribe(subscriptions, subscription, state) {
+	state.aborter?.cancel();
+	removeSubscription(subscriptions, subscription, state);
+}
+const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
 //#endregion
-export { clearSubscriptions, getSubscription, getSubscriptions, isSubscription };
+export { SUBSCRIPTION_NAME, createSubscriptions, isSubscription };

package/dist/internal/value/equal.mjs

@@ -60,7 +60,7 @@ function equalPlainObject(first, second, options) {
 		firstKeys = firstKeys.filter((key) => filterKey(key, options));
 		secondKeys = secondKeys.filter((key) => filterKey(key, options));
 	}
-	const secondSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
+	const secondSet = secondKeys.length >= EQUAL_MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
 	const { length } = firstKeys;
 	if (length !== secondKeys.length) return false;
 	for (let index = 0; index < length; index += 1) {
@@ -105,9 +105,9 @@ function equalValue(first, second, options) {
 		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
 		case first instanceof Date && second instanceof Date: return Object.is(first.getTime(), second.getTime());
 		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
-		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ERROR_PROPERTIES, options);
+		case first instanceof Error && second instanceof Error: return equalProperties(first, second, EQUAL_ERROR_PROPERTIES, options);
 		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
-		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, EXPRESSION_PROPERTIES, options);
+		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, EQUAL_EXPRESSION_PROPERTIES, options);
 		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
 		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
 		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
@@ -169,8 +169,8 @@ function registerEqualizer(constructor, handler) {
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
-const ERROR_PROPERTIES = ["name", "message"];
-const EXPRESSION_PROPERTIES = ["source", "flags"];
-const MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_ERROR_PROPERTIES = ["name", "message"];
+const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
+const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
 export { deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };

package/dist/internal/value/misc.mjs

@@ -7,8 +7,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
-	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
+	if (typeof data !== "object" || data === null) return error(MISC_NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(MISC_NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -24,24 +24,24 @@ function getNestedValue(data, path, ignoreCase) {
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
-	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
-	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
+	if (!MISC_EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(MISC_EXPRESSION_BRACKET, ".$1").replace(MISC_EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
-		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
+		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(NESTED_MESSAGE_MISSING);
+		if (get) return key in data ? ok(data[key]) : error(MISC_NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(NESTED_MESSAGE_MISSING);
+	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }
-const EXPRESSION_BRACKET = /\[(\w+)\]/g;
-const EXPRESSION_DOTS = /^\.|\.$/g;
-const EXPRESSION_NESTED = /\.|\[\w+\]/;
-const NESTED_MESSAGE_INPUT = "Expected data to be an object";
-const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
-const NESTED_MESSAGE_PATH = "Expected path to be a string";
-const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+const MISC_EXPRESSION_BRACKET = /\[(\w+)\]/g;
+const MISC_EXPRESSION_DOTS = /^\.|\.$/g;
+const MISC_EXPRESSION_NESTED = /\.|\[\w+\]/;
+const MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+const MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/set.mjs

@@ -20,7 +20,7 @@ function setValue(data, path, value, ignoreCase) {
 		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(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -28,6 +28,6 @@ function setValue(data, path, value, ignoreCase) {
 	}
 	return data;
 }
-const EXPRESSION_INDEX = /^\d+$/;
+const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
 export { setValue };

package/dist/logger.mjs

@@ -1,13 +1,14 @@
 import { noop } from "./internal/function/misc.mjs";
+import { getString } from "./internal/string.mjs";
 //#region src/logger.ts
 function isLogger(value) {
-	return isLoggerInstance(NAME_LOGGER, value);
+	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[KEY_LOGGER] === name;
+	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
 }
 function isTimedLogger(value) {
-	return isLoggerInstance(NAME_TIMED, value);
+	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
 function timedLogger(label) {
 	function stop() {
@@ -26,35 +27,20 @@ function timedLogger(label) {
 	};
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_TIMED
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
 		active: {
 			enumerable: true,
-			get() {
-				return state.started && !state.stopped && enabled;
-			}
-		},
-		log: {
-			enumerable: true,
-			get() {
-				return this.active ? logger : noop;
-			}
+			get: () => state.started && !state.stopped && enabled
 		},
-		stop: {
-			enumerable: true,
-			get() {
-				return instance.active ? stop() : noop;
-			}
-		}
+		log: { get: () => instance.active ? logger : noop },
+		stop: { get: () => instance.active ? stop() : noop }
 	});
 	if (state.started) console.time(label);
 	return Object.freeze(instance);
 }
-const KEY_LOGGER = "$logger";
-const NAME_LOGGER = "Logger";
-const NAME_TIMED = "TimedLogger";
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
 const methods = [
 	"debug",
 	"dir",
@@ -73,25 +59,15 @@ const methods = [
 const Logger = (() => {
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_LOGGER
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
 		enabled: {
 			enumerable: true,
-			get() {
-				return enabled;
-			},
-			set(value) {
+			get: () => enabled,
+			set: (value) => {
 				enabled = typeof value === "boolean" ? value : enabled;
 			}
 		},
-		time: {
-			enumerable: true,
-			value(label) {
-				return timedLogger(label);
-			}
-		}
+		time: { value: (label) => timedLogger(getString(label)) }
 	});
 	for (const method of methods) Object.defineProperty(instance, method, {
 		enumerable: true,