@oscarpalmer/atoms 0.203.0 → 0.204.0

package/dist/internal/{abort.d.mts → aborter.d.mts}

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../models.mjs";
-//#region src/internal/abort.d.ts
+//#region src/internal/aborter.d.ts
 export type Aborter = {
   callback: GenericCallback;
   signal: AbortSignal;

package/dist/internal/{abort.mjs → aborter.mjs}

@@ -1,4 +1,4 @@
-//#region src/internal/abort.ts
+//#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
 	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);

package/dist/internal/array/get.mjs

@@ -6,13 +6,14 @@ function getArray(value, indiced) {
 	if (value instanceof Set) return [...value.values()];
 	if (isNonPlainObject(value)) return [value];
 	if (indiced !== true) return Object.entries(value);
-	const keys = Object.keys(value);
+	const obj = value;
+	const keys = Object.keys(obj);
 	const { length } = keys;
 	const array = [];
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const asNumber = Number.parseInt(key, 10);
-		if (!Number.isNaN(asNumber)) array[asNumber] = value[key];
+		if (!Number.isNaN(asNumber)) array[asNumber] = obj[key];
 	}
 	return array;
 }

package/dist/internal/array/index-of.mjs

@@ -7,6 +7,5 @@ function lastIndexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
 indexOf.last = lastIndexOf;
-Object.defineProperty(indexOf, "last", { value: lastIndexOf });
 //#endregion
 export { indexOf, lastIndexOf };

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

@@ -78,5 +78,5 @@ export declare function assertIs<Value>(condition: (value: unknown) => value is
  * @param error Error constructor _(defaults to `Error`)_
  * @returns _Asserter_
  */
-export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted = NestedPick<Value, Path>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<Asserted>;
+export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<NestedPick<Value, Path>>;
 //#endregion

package/dist/internal/function/assert.mjs

@@ -92,12 +92,5 @@ assert.defined = assertDefined;
 assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
 assert.property = assertProperty;
-Object.defineProperties(assert, {
-	condition: { value: assertCondition },
-	defined: { value: assertDefined },
-	instanceOf: { value: assertInstanceOf },
-	is: { value: assertIs },
-	property: { value: assertProperty }
-});
 //#endregion
 export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };

package/dist/internal/function/limit.mjs

@@ -4,33 +4,29 @@ const LIMITER_NAME_ASYNC = "asyncLimiter";
 const LIMITER_NAME_SYNC = "limiter";
 const LIMITER_PROPERTY = "$limiter";
 function AsyncLimiter(type, callback, time) {
-	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+	this[LIMITER_SYMBOL] = {
 		callback,
 		type,
 		interval: getNumberOrDefault(time, 0),
 		parameters: [],
 		throttle: type === LIMITER_THROTTLE
-	} });
+	};
 }
-Object.defineProperties(AsyncLimiter.prototype, {
-	[LIMITER_PROPERTY]: { value: LIMITER_NAME_ASYNC },
-	cancel: { value: cancelAsyncLimiter },
-	run: { value: runAsyncLimiter }
-});
+AsyncLimiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_ASYNC;
+AsyncLimiter.prototype.cancel = cancelAsyncLimiter;
+AsyncLimiter.prototype.run = runAsyncLimiter;
 function Limiter(type, callback, time) {
-	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+	this[LIMITER_SYMBOL] = {
 		callback,
 		type,
 		interval: getNumberOrDefault(time, 0),
 		parameters: [],
 		throttle: type === LIMITER_THROTTLE
-	} });
+	};
 }
-Object.defineProperties(Limiter.prototype, {
-	[LIMITER_PROPERTY]: { value: LIMITER_NAME_SYNC },
-	cancel: { value: cancelLimiter },
-	run: { value: runLimiter }
-});
+Limiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_SYNC;
+Limiter.prototype.cancel = cancelLimiter;
+Limiter.prototype.run = runLimiter;
 function cancelAsyncLimiter() {
 	const state = this[LIMITER_SYMBOL];
 	if (state.timer != null) clearTimer(state.timer);

package/dist/internal/function/memoize.mjs

@@ -3,32 +3,28 @@ import { getString, join } from "../string/misc.mjs";
 import { getNumberOrDefault } from "../defaults.mjs";
 import { SizedMap } from "../sized/map.mjs";
 //#region src/internal/function/memoize.ts
-const MEMOIZED_PROPERTY = "$memoized";
 function Memoized(callback, options) {
-	Object.defineProperty(this, MEMOIZED_SYMBOL, { value: {
+	this[MEMOIZED_SYMBOL] = {
 		options,
 		cache: new SizedMap(options.cacheSize),
 		getter: void 0
-	} });
+	};
 	this[MEMOIZED_SYMBOL].getter = createGetter(this[MEMOIZED_SYMBOL], callback);
-	Object.defineProperties(this, {
-		maximum: {
-			enumerable: true,
-			get: () => this[MEMOIZED_SYMBOL].cache.maximum
-		},
-		size: {
-			enumerable: true,
-			get: () => this[MEMOIZED_SYMBOL].cache.size
-		}
-	});
 }
+Memoized.prototype.clear = clearMemoized;
+Memoized.prototype.delete = deleteMemoizedValue;
+Memoized.prototype.get = getMemoizedValue;
+Memoized.prototype.has = hasMemoizedValue;
+Memoized.prototype.run = runMemoized;
 Object.defineProperties(Memoized.prototype, {
-	[MEMOIZED_PROPERTY]: { value: true },
-	clear: { value: clearMemoized },
-	delete: { value: deleteMemoizedValue },
-	get: { value: getMemoizedValue },
-	has: { value: hasMemoizedValue },
-	run: { value: runMemoized }
+	maximum: {
+		enumerable: true,
+		get: getMemoizedMaximum
+	},
+	size: {
+		enumerable: true,
+		get: getMemoizedSize
+	}
 });
 function clearMemoized() {
 	this[MEMOIZED_SYMBOL].cache.clear();
@@ -52,6 +48,12 @@ function createMemoizationOptions(input) {
 		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
+function getMemoizedMaximum() {
+	return this[MEMOIZED_SYMBOL].cache.maximum;
+}
+function getMemoizedSize() {
+	return this[MEMOIZED_SYMBOL].cache.size;
+}
 function getMemoizedValue(key) {
 	return this[MEMOIZED_SYMBOL].cache.get(key);
 }
@@ -75,6 +77,6 @@ function runMemoized(...parameters) {
 const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
 const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 const MEMOIZED_KEY_SEPARATOR = "_";
-const MEMOIZED_SYMBOL = Symbol(MEMOIZED_PROPERTY);
+const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
 export { memoize };

package/dist/internal/function/work.mjs

@@ -59,7 +59,5 @@ const assertFlowFunctions = assert.condition((value) => Array.isArray(value) &&
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
 flow.async = asyncFlow;
 pipe.async = asyncPipe;
-Object.defineProperty(flow, "async", { value: asyncFlow });
-Object.defineProperty(pipe, "async", { value: asyncPipe });
 //#endregion
 export { asyncFlow, asyncPipe, flow, pipe };

package/dist/internal/herald.mjs

@@ -9,23 +9,19 @@ function Events(herald, state) {
 }
 Events.prototype[HERALD_PROPERTY] = HERALD_NAME_EVENTS;
 function Herald(state) {
-	Object.defineProperty(this, HERALD_SYMBOL, { value: {
+	this[HERALD_SYMBOL] = {
 		state,
 		events: new Events(this, state)
-	} });
+	};
 }
-Object.defineProperties(Herald.prototype, {
-	[HERALD_PROPERTY]: { value: HERALD_NAME_HERALD },
-	clear: { value: clearHerald },
-	emit: { value: emitForHerald },
-	events: {
-		enumerable: true,
-		get() {
-			return this[HERALD_SYMBOL].events;
-		}
-	},
-	observed: { value: eventIsObserved },
-	subscribe: { value: subscribeToHerald }
+Herald.prototype[HERALD_PROPERTY] = HERALD_NAME_HERALD;
+Herald.prototype.clear = clearHerald;
+Herald.prototype.emit = emitForHerald;
+Herald.prototype.observed = eventIsObserved;
+Herald.prototype.subscribe = subscribeToHerald;
+Object.defineProperty(Herald.prototype, "events", {
+	enumerable: true,
+	get: getHeraldEvents
 });
 function clearHerald() {
 	this[HERALD_SYMBOL].state.store.clear();
@@ -63,6 +59,9 @@ function emitForHerald(event, ...parameters) {
 function eventIsObserved(event) {
 	return (this[HERALD_SYMBOL].state.store.items.keyed?.get(event)?.size ?? 0) > 0;
 }
+function getHeraldEvents() {
+	return this[HERALD_SYMBOL].events;
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -101,7 +100,7 @@ function isHeraldInstance(name, value) {
 * @returns `true` if the value is a herald subscription, otherwise `false`
 */
 function isHeraldSubscription(value) {
-	return isSubscription(value) && value[HERALD_PROPERTY] === "subscription";
+	return isSubscription(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === "subscription";
 }
 function subscribeToHerald(key, callback, signal) {
 	const { state } = this[HERALD_SYMBOL];

package/dist/internal/result/misc.mjs

@@ -1,4 +1,4 @@
-import { isNonPlainObject } from "../is.mjs";
+import { isPlainObject } from "../is.mjs";
 //#region src/internal/result/misc.ts
 function error(value, original) {
 	return getError(value, original);
@@ -27,8 +27,7 @@ function isResult(value) {
 	return isResultValue(value, true) || isResultValue(value, false);
 }
 function isResultValue(value, okValue) {
-	if (isNonPlainObject(value)) return false;
-	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
 }
 /**
 * Creates an ok result
@@ -49,7 +48,5 @@ const RESULT_PROPERTY_ERROR = "error";
 const RESULT_PROPERTY_VALUE = "value";
 error.is = isError;
 ok.is = isOk;
-Object.defineProperty(error, "is", { value: isError });
-Object.defineProperty(ok, "is", { value: isOk });
 //#endregion
 export { error, getError, isError, isOk, isResult, ok, unwrap };

package/dist/internal/subscription.mjs

@@ -1,44 +1,36 @@
 import { isKey, isPlainObject } from "./is.mjs";
-import { createAborter } from "./abort.mjs";
+import { createAborter } from "./aborter.mjs";
 //#region src/internal/subscription.ts
 const SUBSCRIPTION_NAME = "subscription";
 const SUBSCRIPTION_PROPERTY = "$subscription";
 const SUBSCRIPTION_STORE = "subscriptions";
 function Subscription(state, property, parameters) {
-	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: state });
+	this[SUBSCRIPTION_SYMBOL] = state;
+	this[property.key] = property.value;
 	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
-	Object.defineProperties(this, {
-		[property.key]: { value: property.value },
-		active: {
-			enumerable: true,
-			get: () => (state.parameters?.isActive?.() ?? true) && state.active
-		}
-	});
 	addSubscription(this);
 }
-Object.defineProperties(Subscription.prototype, {
-	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
-	unsubscribe: { value: removeSubscription }
+Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
+Subscription.prototype.unsubscribe = removeSubscription;
+Object.defineProperty(Subscription.prototype, "active", {
+	enumerable: true,
+	get: getSubscriptionActive
 });
 function Subscriptions(parameters) {
 	const { keys, property } = createSubscriptionsParameters(parameters);
-	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: createSubscriptionsState(property, keys) });
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
 }
+Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
+Subscriptions.prototype.clear = clearSubscriptions;
+Subscriptions.prototype.create = createSubscription;
 Object.defineProperties(Subscriptions.prototype, {
-	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
-	clear: { value: clearSubscriptions },
-	create: { value: createSubscription },
 	items: {
 		enumerable: true,
-		get() {
-			return this[SUBSCRIPTION_SYMBOL].items;
-		}
+		get: getSubscriptionsItems
 	},
 	values: {
 		enumerable: true,
-		get() {
-			return this[SUBSCRIPTION_SYMBOL].values;
-		}
+		get: getSubscriptionsValues
 	}
 });
 function addSubscription(instance) {
@@ -101,6 +93,16 @@ function getExistingSubscription(subscriptions, state) {
 	const { parameters } = state;
 	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
+function getSubscriptionActive() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	return (state.parameters?.isActive?.() ?? true) && state.active;
+}
+function getSubscriptionsItems() {
+	return this[SUBSCRIPTION_SYMBOL].items;
+}
+function getSubscriptionsValues() {
+	return this[SUBSCRIPTION_SYMBOL].values;
+}
 function createSubscriptionParameters(input) {
 	const values = isPlainObject(input) ? input : {};
 	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);

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

@@ -13,7 +13,7 @@ export declare namespace compare {
   var deregister: typeof deregisterComparator;
   var handler: {
     base: {
-      handlers: WeakMap<Constructor, string | GenericCallback>;
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
       options: {
         callback: GenericCallback;
         method?: string;

package/dist/internal/value/compare.mjs

@@ -85,10 +85,5 @@ const compareHandler = createCompareHandler(compare, {
 compare.deregister = deregisterComparator;
 compare.handler = compareHandler;
 compare.register = registerComparator;
-Object.defineProperties(compare, {
-	deregister: { value: deregisterComparator },
-	handler: { value: compareHandler },
-	register: { value: registerComparator }
-});
 //#endregion
 export { compare, deregisterComparator, registerComparator };

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

@@ -95,7 +95,7 @@ export declare namespace equal {
   var deregister: typeof deregisterEqualizer;
   var handler: {
     base: {
-      handlers: WeakMap<Constructor, string | GenericCallback>;
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
       options: {
         callback: GenericCallback;
         method?: string;

package/dist/internal/value/equal.mjs

@@ -2,13 +2,11 @@ import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../i
 import { createCompareHandler } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
 function Equalizer(options) {
-	Object.defineProperty(this, EQUAL_SYMBOL, { value: options });
+	this[EQUAL_SYMBOL] = options;
 }
-Object.defineProperties(Equalizer.prototype, {
-	compare: { value: compare },
-	deregister: { value: deregisterEqualizer },
-	register: { value: registerEqualizer }
-});
+Equalizer.prototype.compare = compare;
+Equalizer.prototype.deregister = deregisterEqualizer;
+Equalizer.prototype.register = registerEqualizer;
 function compare(first, second) {
 	return equalValue(first, second, this[EQUAL_SYMBOL]);
 }
@@ -181,11 +179,5 @@ equal.deregister = deregisterEqualizer;
 equal.handler = equalHandler;
 equal.initialize = initializeEqualizer;
 equal.register = registerEqualizer;
-Object.defineProperties(equal, {
-	deregister: { value: deregisterEqualizer },
-	handler: { value: equalHandler },
-	initialize: { value: initializeEqualizer },
-	register: { value: registerEqualizer }
-});
 //#endregion
 export { deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };

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

@@ -1,7 +1,7 @@
 import { Constructor, GenericCallback } from "../../models.mjs";
 //#region src/internal/value/handlers.d.ts
 type BaseHandler = {
-  handlers: WeakMap<Constructor, string | GenericCallback>;
+  handlers: WeakMap<WeakKey, string | GenericCallback>;
   options: BaseHandlerOptions;
   owner: GenericCallback;
   deregister: (constructor: Constructor) => void;

package/dist/internal/value/handlers.mjs

@@ -5,19 +5,17 @@ function BaseHandler(owner, options) {
 	this.owner = owner;
 	this.options = options;
 }
-Object.defineProperties(BaseHandler.prototype, {
-	deregister: { value: deregisterHandler },
-	get: { value: getHandler },
-	register: { value: registerHandler }
-});
+BaseHandler.prototype.deregister = deregisterHandler;
+BaseHandler.prototype.get = getHandler;
+BaseHandler.prototype.register = registerHandler;
 function CompareHandler(base) {
 	this.base = base;
 }
-Object.defineProperties(CompareHandler.prototype, { handle: { value: handleComparison } });
+CompareHandler.prototype.handle = handleComparison;
 function ValueHandler(value) {
 	this.base = value;
 }
-Object.defineProperties(ValueHandler.prototype, { handle: { value: handleValue } });
+ValueHandler.prototype.handle = handleValue;
 function createBaseHandler(owner, options) {
 	return new BaseHandler(owner, options);
 }

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

@@ -3,6 +3,6 @@ import { Result } from "../result/models.mjs";
 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<unknown, 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.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.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/logger.mjs

@@ -4,36 +4,32 @@ import { getString } from "./internal/string/misc.mjs";
 const LOGGER_NAME = "Logger";
 const LOGGER_NAME_TIMED = "TimedLogger";
 const LOGGER_PROPERTY = "$logger";
-function Lumberjack() {
-	for (const method of methods) {
-		const bound = console[method].bind(console);
-		Object.defineProperty(this, method, {
-			enumerable: true,
-			get() {
-				return enabled ? bound : noop;
-			}
-		});
-	}
-}
+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: () => enabled,
-		set: (value) => {
-			enabled = typeof value === "boolean" ? value : enabled;
-		}
+		get: getLoggerEnabled,
+		set: setLoggerEnabled
 	},
-	time: { value: (label) => new TimeLogger(getString(label)) }
+	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) {
-	Object.defineProperty(this, LOGGER_SYMBOL, { value: {
+	this[LOGGER_SYMBOL] = {
 		label,
 		started: enabled,
 		stopped: false
-	} });
+	};
 	this[LOGGER_SYMBOL].isActive = () => {
-		return this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped && enabled;
+		return enabled && this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped;
 	};
 	if (this[LOGGER_SYMBOL].started) console.time(label);
 }
@@ -41,43 +37,48 @@ TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
 Object.defineProperties(TimeLogger.prototype, {
 	active: {
 		enumerable: true,
-		get() {
-			return this[LOGGER_SYMBOL].isActive();
-		}
+		get: getTimeLoggerActive
 	},
-	log: { get() {
-		const state = this[LOGGER_SYMBOL];
-		return state.isActive() ? console.timeLog.bind(console, state.label) : noop;
-	} },
-	stop: { get() {
-		const state = this[LOGGER_SYMBOL];
-		if (state.isActive()) {
-			state.stopped = true;
-			return console.timeEnd.bind(console, state.label);
-		}
-		return noop;
-	} }
+	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 isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
+function setLoggerEnabled(value) {
+	enabled = typeof value === "boolean" ? value : enabled;
+}
 const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
-const methods = [
-	"debug",
-	"dir",
-	"error",
-	"info",
-	"log",
-	"table",
-	"trace",
-	"warn"
-];
 /**
 * A logger that can be used to log messages to the console
 *

package/dist/promise/delay.mjs

@@ -1,4 +1,4 @@
-import { createAborter } from "../internal/abort.mjs";
+import { createAborter } from "../internal/aborter.mjs";
 import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";