@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/internal/value/equal.mjs

@@ -1,6 +1,17 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
-import { createCompareHandlers } from "./handlers.mjs";
+import { createCompareHandler } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
+function Equalizer(options) {
+	Object.defineProperty(this, EQUAL_SYMBOL, { value: options });
+}
+Object.defineProperties(Equalizer.prototype, {
+	compare: { value: compare },
+	deregister: { value: deregisterEqualizer },
+	register: { value: registerEqualizer }
+});
+function compare(first, second) {
+	return equalValue(first, second, this[EQUAL_SYMBOL]);
+}
 function createEqualOptions(input) {
 	const options = {
 		ignoreCase: false,
@@ -35,7 +46,7 @@ function createEqualOptions(input) {
 * @param constructor Class constructor
 */
 function deregisterEqualizer(constructor) {
-	equal.handlers.deregister(constructor);
+	equalHandler.base.deregister(constructor);
 }
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
@@ -46,10 +57,6 @@ function filterKey(key, options) {
 function equal(first, second, options) {
 	return equalValue(first, second, createEqualOptions(options));
 }
-equal.handlers = createCompareHandlers(equal, { callback: Object.is });
-equal.deregister = deregisterEqualizer;
-equal.initialize = initializeEqualizer;
-equal.register = registerEqualizer;
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -138,7 +145,7 @@ function equalValue(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);
 		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		default: return equal.handlers.handle(first, second, options);
+		default: return equalHandler.handle(first, second, options);
 	}
 }
 /**
@@ -150,11 +157,7 @@ function equalValue(first, second, options) {
 * @returns Equalizer function
 */
 function initializeEqualizer(options) {
-	const actual = createEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.deregister = deregisterEqualizer;
-	equalizer.register = registerEqualizer;
-	return equalizer;
+	return new Equalizer(createEqualOptions(options));
 }
 /**
 * Register a equality comparison function for a specific class
@@ -165,12 +168,24 @@ function initializeEqualizer(options) {
 * @param handler Comparison function
 */
 function registerEqualizer(constructor, handler) {
-	equal.handlers.register(constructor, handler);
+	equalHandler.base.register(constructor, handler);
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
 const EQUAL_ERROR_PROPERTIES = ["name", "message"];
 const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
 const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_SYMBOL = Symbol("equal");
+const equalHandler = createCompareHandler(equal, { callback: Object.is });
+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/get.d.mts

@@ -17,7 +17,7 @@ import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
  * getValue(data, 'foo.nope');    // => undefined
  * ```
  */
-declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
+export declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
 /**
  * Get the value from an object using an unknown path
  *
@@ -36,6 +36,5 @@ declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data
  * getValue(data, 'foo.nope');          // => undefined
  * ```
  */
-declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
-//#endregion
-export { getValue };
+export declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
+//#endregion

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

@@ -1,18 +1,28 @@
 import { Constructor, GenericCallback } from "../../models.mjs";
 //#region src/internal/value/handlers.d.ts
-type Options = {
+type BaseHandler = {
+  handlers: WeakMap<Constructor, string | GenericCallback>;
+  options: BaseHandlerOptions;
+  owner: GenericCallback;
+  deregister: (constructor: Constructor) => void;
+  get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+};
+type BaseHandlerOptions = {
   callback: GenericCallback;
   method?: string;
 };
-declare function createCompareHandlers<Value>(owner: GenericCallback, options: Options): {
-  deregister(constructor: Constructor): void;
+type CompareHandler<Value> = {
+  base: BaseHandler;
   handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
-  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
-declare function createSelfHandlers(owner: GenericCallback, options: Options): {
-  deregister(constructor: Constructor): void;
+type ValueHandler = {
+  base: BaseHandler;
   handle(value: unknown, ...parameters: unknown[]): unknown;
-  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
-//#endregion
-export { createCompareHandlers, createSelfHandlers };
+declare function BaseHandler(this: any, owner: GenericCallback, options: BaseHandlerOptions): void;
+declare function CompareHandler(this: any, base: BaseHandler): void;
+declare function ValueHandler(this: any, value: BaseHandler): void;
+export declare function createCompareHandler<Value>(owner: GenericCallback, options: BaseHandlerOptions): CompareHandler<Value>;
+export declare function createValueHandler(owner: GenericCallback, options: BaseHandlerOptions): ValueHandler;
+//#endregion

package/dist/internal/value/handlers.mjs

@@ -1,57 +1,57 @@
 import { isNonConstructor } from "../is.mjs";
 //#region src/internal/value/handlers.ts
-function createCompareHandlers(owner, options) {
-	const handlers = createHandlers(owner, options);
-	return {
-		deregister(constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(first, second, ...parameters) {
-			const handler = handlers.get(first, second);
-			if (handler == null) return options.callback(first, second, ...parameters);
-			return typeof handler === "function" ? handler(first, second) : first[handler](second);
-		},
-		register(constructor, handler) {
-			handlers.register(constructor, handler);
-		}
-	};
-}
-function createHandlers(owner, options) {
-	const handlers = /* @__PURE__ */ new WeakMap();
-	return {
-		deregister(constructor) {
-			handlers.delete(constructor);
-		},
-		get(first, second) {
-			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
-		},
-		register(constructor, handler) {
-			if (isNonConstructor(constructor) || handler === owner) return;
-			let actual = handler ?? options.method;
-			if (typeof actual !== "function" && typeof actual !== "string") return;
-			if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
-			if (actual != null) handlers.set(constructor, actual);
-		}
-	};
-}
-function createSelfHandlers(owner, options) {
-	const handlers = createHandlers(owner, options);
-	return {
-		deregister(constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(value, ...parameters) {
-			const handler = handlers.get(value, value);
-			if (handler == null) return options.callback(value, ...parameters);
-			return typeof handler === "function" ? handler(value) : value[handler]();
-		},
-		register(constructor, handler) {
-			handlers.register(constructor, handler);
-		}
-	};
+function BaseHandler(owner, options) {
+	this.handlers = /* @__PURE__ */ new WeakMap();
+	this.owner = owner;
+	this.options = options;
+}
+Object.defineProperties(BaseHandler.prototype, {
+	deregister: { value: deregisterHandler },
+	get: { value: getHandler },
+	register: { value: registerHandler }
+});
+function CompareHandler(base) {
+	this.base = base;
+}
+Object.defineProperties(CompareHandler.prototype, { handle: { value: handleComparison } });
+function ValueHandler(value) {
+	this.base = value;
+}
+Object.defineProperties(ValueHandler.prototype, { handle: { value: handleValue } });
+function createBaseHandler(owner, options) {
+	return new BaseHandler(owner, options);
+}
+function createCompareHandler(owner, options) {
+	return new CompareHandler(createBaseHandler(owner, options));
+}
+function createValueHandler(owner, options) {
+	return new ValueHandler(createBaseHandler(owner, options));
+}
+function deregisterHandler(value) {
+	this.handlers.delete(value);
+}
+function getHandler(first, second) {
+	if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return this.handlers.get(first.constructor);
+}
+function handleComparison(first, second, ...parameters) {
+	const handler = this.base.get(first, second);
+	if (handler == null) return this.base.options.callback(first, second, ...parameters);
+	return typeof handler === "function" ? handler(first, second) : first[handler](second);
 }
 function isConstructable(value) {
 	return typeof value === "object" && value !== null;
 }
+function registerHandler(constructor, handler) {
+	if (isNonConstructor(constructor) || handler === this.owner) return;
+	let actual = handler ?? this.options.method;
+	if (typeof actual !== "function" && typeof actual !== "string") return;
+	if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
+	if (actual != null) this.handlers.set(constructor, actual);
+}
+function handleValue(value, ...parameters) {
+	const handler = this.base.get(value, value);
+	if (handler == null) return this.base.options.callback(value, ...parameters);
+	return typeof handler === "function" ? handler(value) : value[handler]();
+}
 //#endregion
-export { createCompareHandlers, createSelfHandlers };
+export { createCompareHandler, createValueHandler };

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

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

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

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

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

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

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

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

package/dist/is.d.mts

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

package/dist/logger.d.mts

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

package/dist/logger.mjs

@@ -1,46 +1,73 @@
 import { noop } from "./internal/function/misc.mjs";
 import { getString } from "./internal/string/misc.mjs";
 //#region src/logger.ts
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
+function Lumberjack() {
+	for (const method of methods) {
+		const bound = console[method].bind(console);
+		Object.defineProperty(this, method, {
+			enumerable: true,
+			get() {
+				return enabled ? bound : noop;
+			}
+		});
+	}
+}
+Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+Object.defineProperties(Lumberjack.prototype, {
+	enabled: {
+		enumerable: true,
+		get: () => enabled,
+		set: (value) => {
+			enabled = typeof value === "boolean" ? value : enabled;
+		}
+	},
+	time: { value: (label) => new TimeLogger(getString(label)) }
+});
+function TimeLogger(label) {
+	Object.defineProperty(this, LOGGER_SYMBOL, { value: {
+		label,
+		started: enabled,
+		stopped: false
+	} });
+	this[LOGGER_SYMBOL].isActive = () => {
+		return this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped && enabled;
+	};
+	if (this[LOGGER_SYMBOL].started) console.time(label);
+}
+TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
+Object.defineProperties(TimeLogger.prototype, {
+	active: {
+		enumerable: true,
+		get() {
+			return this[LOGGER_SYMBOL].isActive();
+		}
+	},
+	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;
+	} }
+});
 function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
 	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
 }
-function isTimedLogger(value) {
+function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
-function timedLogger(label) {
-	function stop() {
-		const fn = stopper;
-		state.stopped = true;
-		logger = void 0;
-		stopper = void 0;
-		return fn;
-	}
-	let logger = console.timeLog.bind(console, label);
-	let stopper = console.timeEnd.bind(console, label);
-	const state = {
-		label,
-		started: enabled,
-		stopped: false
-	};
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
-		active: {
-			enumerable: true,
-			get: () => state.started && !state.stopped && enabled
-		},
-		log: { get: () => instance.active ? logger : noop },
-		stop: { get: () => instance.active ? stop() : noop }
-	});
-	if (state.started) console.time(label);
-	return Object.freeze(instance);
-}
-const LOGGER_NAME = "Logger";
-const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
+const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
 const methods = [
 	"debug",
 	"dir",
@@ -56,27 +83,7 @@ const methods = [
 *
 * _(Logging can be enabled or disabled by setting the `enabled` property)_
 */
-const Logger = (() => {
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
-		enabled: {
-			enumerable: true,
-			get: () => enabled,
-			set: (value) => {
-				enabled = typeof value === "boolean" ? value : enabled;
-			}
-		},
-		time: { value: (label) => timedLogger(getString(label)) }
-	});
-	for (const method of methods) Object.defineProperty(instance, method, {
-		enumerable: true,
-		get() {
-			return enabled ? console[method].bind(console) : noop;
-		}
-	});
-	return Object.freeze(instance);
-})();
+const Logger = new Lumberjack();
 let enabled = true;
 //#endregion
-export { Logger, isLogger, isTimedLogger };
+export { Logger, isLogger, isTimeLogger };