@oscarpalmer/atoms 0.189.0 → 0.190.0

package/dist/index.mjs

@@ -1390,7 +1390,7 @@ function isOk(value) {
 * Is the value a _Result_?
 *
 * @param value Value to check
-* @returns `true` if the value is a _Result_, `false` otherwise
+* @returns `true` if the value is a _Result_, otherwise `false`
 */
 function isResult(value) {
 	return isResultValue(value, true) || isResultValue(value, false);
@@ -1735,95 +1735,6 @@ var SizedMap = class extends Map {
 };
 //#endregion
 //#region src/function/memoize.ts
-/**
-* A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
-*/
-var Memoized = class {
-	#state;
-	/**
-	* Maximum cache size
-	*
-	* @returns Maximum cache size _(or `Number.NaN` if the instance has been destroyed)_
-	*/
-	get maximum() {
-		return this.#state.cache?.maximum ?? NaN;
-	}
-	/**
-	* Current cache size
-	*
-	* @returns Current cache size _(or `Number.NaN` if the instance has been destroyed)_
-	*/
-	get size() {
-		return this.#state.cache?.size ?? NaN;
-	}
-	constructor(callback, options) {
-		const cache = new SizedMap(options.cacheSize);
-		const getter = (...parameters) => {
-			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
-			if (cache.has(key)) return cache.get(key);
-			const value = callback(...parameters);
-			cache.set(key, value);
-			return value;
-		};
-		this.#state = {
-			cache,
-			getter
-		};
-	}
-	/**
-	* Clear the cache
-	*/
-	clear() {
-		this.#state.cache?.clear();
-	}
-	/**
-	* Delete a result from the cache
-	*
-	* @param key Key to delete
-	* @returns `true` if the key existed and was removed, otherwise `false`
-	*/
-	delete(key) {
-		return this.#state.cache?.delete(key) ?? false;
-	}
-	/**
-	* Destroy the instance
-	*
-	* _(When a Memoized instance is destroyed, its cache and callback are removed, and calls to `run` will throw an error)_
-	*/
-	destroy() {
-		this.#state.cache?.clear();
-		this.#state.cache = void 0;
-		this.#state.getter = void 0;
-	}
-	/**
-	* Get a result from the cache
-	*
-	* @param key Key to get
-	* @returns Cached result or `undefined` if it does not exist
-	*/
-	get(key) {
-		return this.#state.cache?.get(key);
-	}
-	/**
-	* Does the result exist?
-	*
-	* @param key Key to check
-	* @returns `true` if the result exists, otherwise `false`
-	*/
-	has(key) {
-		return this.#state.cache?.has(key) ?? false;
-	}
-	/**
-	* Run the callback with the provided parameters
-	*
-	* @param parameters Parameters to pass to the callback
-	* @returns Cached or computed _(then cached)_ result
-	*/
-	run(...parameters) {
-		if (this.#state.cache == null || this.#state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
-		return this.#state.getter(...parameters);
-	}
-};
 function getMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
@@ -1840,7 +1751,49 @@ function getMemoizationOptions(input) {
 */
 function memoize(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MEMOIZED_ERROR_CALLBACK);
-	return new Memoized(callback, getMemoizationOptions(options));
+	const state = { options: getMemoizationOptions(options) };
+	state.cache = new SizedMap(state.options.cacheSize);
+	state.getter = (...parameters) => {
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
+		if (state.cache.has(key)) return state.cache.get(key);
+		const value = callback(...parameters);
+		state.cache?.set(key, value);
+		return value;
+	};
+	const instance = {
+		clear: () => {
+			state.cache?.clear();
+		},
+		delete: (key) => {
+			return state.cache?.delete(key) ?? false;
+		},
+		destroy: () => {
+			state.cache?.clear();
+			state.cache = void 0;
+			state.getter = void 0;
+		},
+		get: (key) => {
+			return state.cache?.get(key);
+		},
+		has: (key) => {
+			return state.cache?.has(key) ?? false;
+		},
+		run: (...parameters) => {
+			if (state.cache == null || state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
+			return state.getter(...parameters);
+		}
+	};
+	Object.defineProperties(instance, {
+		maximum: {
+			enumerable: true,
+			get: () => state.cache?.maximum ?? NaN
+		},
+		size: {
+			enumerable: true,
+			get: () => state.cache?.size ?? NaN
+		}
+	});
+	return Object.freeze(instance);
 }
 const DEFAULT_CACHE_SIZE = 1024;
 const MEMOIZED_ERROR_CALLBACK = "Memoized requires a callback function";
@@ -2029,10 +1982,22 @@ function asyncOnce(callback) {
 		});
 	};
 	Object.defineProperties(fn, {
-		called: { get: () => state.called },
-		cleared: { get: () => state.cleared },
-		error: { get: () => state.error },
-		finished: { get: () => state.finished }
+		called: {
+			enumerable: true,
+			get: () => state.called
+		},
+		cleared: {
+			enumerable: true,
+			get: () => state.cleared
+		},
+		error: {
+			enumerable: true,
+			get: () => state.error
+		},
+		finished: {
+			enumerable: true,
+			get: () => state.finished
+		}
 	});
 	fn.clear = () => {
 		if (!state.called || !state.finished || state.cleared) return;
@@ -2235,93 +2200,17 @@ const assertFlowFunctions = assert.condition((value) => Array.isArray(value) &&
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
 //#endregion
 //#region src/herald.ts
-var Events = class {
-	#herald;
-	constructor(herald) {
-		this.#herald = herald;
-	}
-	/**
-	* Subscribe to an event with a callback
-	*
-	* @param event Event name
-	* @param callback Callback function
-	* @returns Unsubscriber function
-	*/
-	subscribe(event, callback) {
-		return this.#herald.subscribe(event, callback);
-	}
-	/**
-	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
-	*
-	* @param event Event name
-	* @param callback Callback function
-	* @returns Unsubscriber function
-	*/
-	unsubscribe(event, callback) {
-		return this.#herald.unsubscribe(event, callback);
-	}
-};
-/**
-* A _Herald_ is an announcer for named events, allowing emission, subscription, and unsubscription of events
-*/
-var Herald = class {
-	#names;
-	#subscribers = /* @__PURE__ */ new Map();
-	constructor(names) {
-		this.#names = new Set(names);
-		Object.defineProperty(this, "events", { value: new Events(this) });
-	}
-	/**
-	* Remove all event subscribers
-	*/
-	clear() {
-		this.#subscribers.clear();
-	}
-	/**
-	* Emit an event with parameters
-	*
-	* @param event Event name
-	* @param parameters Event parameters
-	*/
-	emit(event, ...parameters) {
-		const subscribers = this.#subscribers.get(event);
-		if (subscribers == null) return;
-		for (const callback of subscribers) callback(...parameters);
-	}
-	/**
-	* Subscribe to an event with a callback
-	*
-	* @param event Event name
-	* @param callback Callback function
-	* @returns Unsubscriber function
-	*/
-	subscribe(event, callback) {
-		if (!this.#names.has(event) || typeof callback !== "function") return noop;
-		let subscribers = this.#subscribers.get(event);
-		if (subscribers == null) {
-			subscribers = /* @__PURE__ */ new Set();
-			this.#subscribers.set(event, subscribers);
-		}
-		subscribers.add(callback);
-		return () => {
-			subscribers?.delete(callback);
-		};
-	}
-	/**
-	* Unsubscribe from an event with a callback _(or all callbacks, if no callback is provided)_
-	*
-	* @param event Event name
-	* @param callback Callback function
-	*/
-	unsubscribe(event, callback) {
-		if (!this.#names.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
-		const subscribers = this.#subscribers.get(event);
-		if (subscribers == null) return;
-		if (callback == null) subscribers.clear();
-		else subscribers.delete(callback);
-		if (callback == null || subscribers.size === 0) this.#subscribers.delete(event);
-	}
-};
+function getEvents(herald) {
+	const events = {
+		subscribe: (event, callback) => herald.subscribe(event, callback),
+		unsubscribe: (event, callback) => herald.unsubscribe(event, callback)
+	};
+	Object.defineProperty(events, KEY_HERALD, {
+		enumerable: false,
+		value: NAME_EVENTS
+	});
+	return Object.freeze(events);
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -2330,9 +2219,75 @@ var Herald = class {
 */
 function herald(names) {
 	if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string")) throw new Error(MESSAGE);
-	return new Herald(names);
+	const set = new Set(names);
+	const subscribers = /* @__PURE__ */ new Map();
+	const instance = {
+		clear() {
+			subscribers.clear();
+		},
+		emit(event, ...parameters) {
+			const callbacks = subscribers.get(event);
+			if (callbacks == null) return;
+			for (const callback of callbacks) callback(...parameters);
+		},
+		subscribe(event, callback) {
+			if (!set.has(event) || typeof callback !== "function") return noop;
+			let eventSubscribers = subscribers.get(event);
+			if (eventSubscribers == null) {
+				eventSubscribers = /* @__PURE__ */ new Set();
+				subscribers.set(event, eventSubscribers);
+			}
+			eventSubscribers.add(callback);
+			return () => {
+				eventSubscribers?.delete(callback);
+			};
+		},
+		unsubscribe(event, callback) {
+			if (!set.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
+			const eventSubscribers = subscribers.get(event);
+			if (eventSubscribers == null) return;
+			if (callback == null) eventSubscribers.clear();
+			else eventSubscribers.delete(callback);
+			if (callback == null || eventSubscribers.size === 0) subscribers.delete(event);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_HERALD]: {
+			enumerable: false,
+			value: NAME_HERALD
+		},
+		events: {
+			enumerable: true,
+			value: getEvents(instance)
+		}
+	});
+	return Object.freeze(instance);
+}
+/**
+* Is the value events for a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is events for a herald, otherwise `false`
+*/
+function isEvents(value) {
+	return isHeraldInstance(NAME_EVENTS, value);
+}
+/**
+* Is the value a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is a herald, otherwise `false`
+*/
+function isHerald(value) {
+	return isHeraldInstance(NAME_HERALD, value);
+}
+function isHeraldInstance(name, value) {
+	return typeof value === "object" && value != null && KEY_HERALD in value && value[KEY_HERALD] === name;
 }
+const KEY_HERALD = "$herald";
 const MESSAGE = "Herald requires an array of event names.";
+const NAME_EVENTS = "events";
+const NAME_HERALD = "herald";
 //#endregion
 //#region src/internal/value/equal.ts
 /**
@@ -2845,45 +2800,6 @@ const MATCH_STARTS_WITH = "startsWith";
 const matchMemoizers = {};
 //#endregion
 //#region src/string/fuzzy.ts
-/**
-* Fuzzy searcher for an array of items
-*/
-var Fuzzy = class {
-	#state;
-	/**
-	* Get items currently being searched through
-	*
-	* @returns Original items
-	*/
-	get items() {
-		return this.#state.items.slice();
-	}
-	/**
-	* Set new items to search through
-	*
-	* @param items New items to search through
-	*/
-	set items(items) {
-		if (Array.isArray(items)) {
-			this.#state.items = items.slice();
-			this.#state.strings = items.map(this.#state.handler);
-		}
-	}
-	/**
-	* Get strings currently being searched through _(the stringified version of `items`)_
-	*
-	* @returns Stringified items
-	*/
-	get strings() {
-		return this.#state.strings.slice();
-	}
-	constructor(state) {
-		this.#state = state;
-	}
-	search(value, options) {
-		return search(this.#state.items, this.#state.strings, value, options == null ? this.#state : getFuzzyOptions(options, this.#state));
-	}
-};
 function getHandler(input) {
 	if (input == null || input === getString) return getString;
 	switch (typeof input) {
@@ -2922,7 +2838,20 @@ function getTolerance(input, state) {
 }
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
-	return new Fuzzy(getFuzzyState(items, configuration));
+	const state = getFuzzyState(items, configuration);
+	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
+	Object.defineProperties(instance, {
+		items: {
+			get: () => state.items.slice(),
+			set: (items) => {
+				if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
+				state.items = items.slice();
+				state.strings = items.map(state.handler);
+			}
+		},
+		strings: { get: () => state.strings.slice() }
+	});
+	return Object.freeze(instance);
 }
 fuzzy.match = fuzzyMatch;
 /**
@@ -2930,7 +2859,7 @@ fuzzy.match = fuzzyMatch;
 *
 * @param haystack Haystack to search through
 * @param needle Needle to search for
-* @returns `true` if the needle matches the haystack in a fuzzy way, `false` otherwise
+* @returns `true` if the needle matches the haystack in a fuzzy way, otherwise `false`
 */
 function fuzzyMatch(haystack, needle) {
 	if (typeof haystack !== "string" || typeof needle !== "string") return false;
@@ -3880,141 +3809,6 @@ function transformValue(value, transformer) {
 //#endregion
 //#region src/beacon.ts
 /**
-* A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
-*/
-var Beacon = class {
-	#options;
-	#state;
-	/**
-	* Is the beacon active?
-	*/
-	get active() {
-		return this.#state.active;
-	}
-	/**
-	* The observable that can be subscribed to
-	*/
-	get observable() {
-		if (!this.#state.active) throw new Error(MESSAGE_BEACON);
-		return this.#state.observable;
-	}
-	/**
-	* The current value
-	*/
-	get value() {
-		return this.#state.value;
-	}
-	constructor(value, options) {
-		const observers = /* @__PURE__ */ new Map();
-		this.#options = getBeaconOptions(options);
-		this.#state = {
-			observers,
-			value,
-			active: true,
-			observable: new Observable(this, observers)
-		};
-	}
-	/**
-	* Destroy the beacon
-	*/
-	destroy() {
-		finishBeacon(this.#state, false);
-	}
-	/**
-	* Emit a new value
-	*
-	* @param value Value to set and emit
-	* @param finish Finish the beacon after emitting? _(defaults to `false`)_
-	*/
-	emit(value, finish) {
-		this.#on(TYPE_NEXT, value, finish);
-	}
-	/**
-	* Emit an error
-	*
-	* @param value Error to emit
-	* @param finish Finish the beacon after emitting? _(defaults to `false`)_
-	*/
-	error(value, finish) {
-		this.#on(TYPE_ERROR, value, finish);
-	}
-	/**
-	* Finish the beacon
-	*/
-	finish() {
-		finishBeacon(this.#state, true);
-	}
-	#on(type, value, finish) {
-		if (!this.#state.active) return;
-		if (type === TYPE_NEXT) {
-			if (this.#options.equal(this.#state.value, value)) return;
-			this.#state.value = value;
-		}
-		for (const [, observer] of this.#state.observers) observer[type]?.(value);
-		if (finish === true) finishBeacon(this.#state, true);
-	}
-};
-/**
-* An observable holds a value and allows observers to subscribe to changes in that value
-*/
-var Observable = class {
-	#state;
-	constructor(instance, observers) {
-		this.#state = {
-			observers,
-			beacon: instance,
-			closed: false
-		};
-	}
-	/**
-	* Destroy the observable
-	*/
-	destroy() {
-		this.#state.closed = true;
-	}
-	subscribe(first, second, third) {
-		if (this.#state.closed) throw new Error(MESSAGE_OBSERVABLE);
-		const observer = getObserver(first, second, third);
-		const instance = new Subscription(this.#state);
-		this.#state.observers.set(instance, observer);
-		observer.next?.(this.#state.beacon.value);
-		return instance;
-	}
-};
-/**
-* A subscription represents an active subscription to an observable, holding its state and allowing it to be destroyed or unsubscribed from
-*/
-var Subscription = class {
-	#state;
-	constructor(state) {
-		this.#state = {
-			...state,
-			closed: false
-		};
-	}
-	/**
-	* Is the subscription closed?
-	*/
-	get closed() {
-		return this.#state.closed || !this.#state.beacon.active;
-	}
-	/**
-	* Destroy the subscription
-	*/
-	destroy() {
-		if (!this.#state.closed) this.unsubscribe();
-	}
-	/**
-	* Unsubscribe from its observable
-	*/
-	unsubscribe() {
-		if (!this.#state.closed) {
-			this.#state.closed = true;
-			this.#state.observers.delete(this);
-		}
-	}
-};
-/**
 * Create a new beacon
 *
 * @param value Initial value
@@ -4022,7 +3816,54 @@ var Subscription = class {
 * @returns Beacon instance
 */
 function beacon(value, options) {
-	return new Beacon(value, options);
+	const state = {
+		value,
+		active: true,
+		observable: void 0,
+		observers: /* @__PURE__ */ new Map(),
+		options: getBeaconOptions(options)
+	};
+	const instance = {
+		close: () => {
+			finishBeacon(state, false);
+		},
+		emit: (value, finish) => {
+			update$1(TYPE_NEXT, state, value, finish);
+		},
+		error: (value, finish) => {
+			update$1(TYPE_ERROR, state, value, finish);
+		},
+		finish: () => {
+			finishBeacon(state, true);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_BEACON]: {
+			enumerable: false,
+			value: NAME_BEACON
+		},
+		active: {
+			enumerable: true,
+			get: () => state.active
+		},
+		closed: {
+			enumerable: true,
+			get: () => !state.active
+		},
+		observable: {
+			enumerable: true,
+			get: () => {
+				if (!state.active) throw new Error(MESSAGE_BEACON);
+				state.observable ??= observe(state);
+				return state.observable;
+			}
+		},
+		value: {
+			enumerable: true,
+			get: () => state.value
+		}
+	});
+	return Object.freeze(instance);
 }
 function finishBeacon(state, emit) {
 	if (!state.active) return;
@@ -4032,10 +3873,11 @@ function finishBeacon(state, emit) {
 	for (let index = 0; index < length; index += 1) {
 		const [subscription, observer] = entries[index];
 		if (emit) observer.complete?.();
-		subscription.destroy();
+		subscription.close();
 	}
-	state.observable?.destroy();
+	state.observable?.close();
 	state.observers.clear();
+	state.observable = void 0;
 }
 function getBeaconOptions(input) {
 	const options = isPlainObject(input) ? input : {};
@@ -4059,11 +3901,134 @@ function getObserver(first, second, third) {
 	}
 	return observer;
 }
-const MESSAGE_BEACON = "Cannot retrieve observable from a destroyed beacon";
-const MESSAGE_OBSERVABLE = "Cannot subscribe to a destroyed observable";
+/**
+* Is the value a beacon?
+*
+* @param value Value to check
+* @returns `true` if the value is a beacon, otherwise `false`
+*/
+function isBeacon(value) {
+	return isBeaconInstance(NAME_BEACON, value);
+}
+function isBeaconInstance(name, value) {
+	return isPlainObject(value) && value[KEY_BEACON] === name;
+}
+/**
+* Is the value an observable?
+*
+* @param value Value to check
+* @returns `true` if the value is an observable, otherwise `false`
+*/
+function isObservable(value) {
+	return isBeaconInstance(NAME_OBSERVABLE, value);
+}
+/**
+* Is the value a subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a subscription, otherwise `false`
+*/
+function isSubscription(value) {
+	return isBeaconInstance(NAME_SUBSCRIPTION, value);
+}
+function observe(beacon) {
+	const state = {
+		beacon,
+		active: beacon.active
+	};
+	const instance = {
+		close: () => {
+			state.active = false;
+		},
+		subscribe(first, second, third) {
+			if (!beacon.active || !state.active) throw new Error(MESSAGE_OBSERVABLE);
+			const observer = getObserver(first, second, third);
+			const subscription = subscribe(state);
+			beacon.observers.set(subscription, observer);
+			observer.next?.(beacon.value);
+			return subscription;
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_BEACON]: {
+			enumerable: false,
+			value: NAME_OBSERVABLE
+		},
+		active: {
+			enumerable: true,
+			get: () => beacon.active && state.active
+		},
+		closed: {
+			enumerable: true,
+			get: () => !beacon.active || !state.active
+		}
+	});
+	return Object.freeze(instance);
+}
+function subscribe(observable) {
+	function unsubscribe() {
+		if (active) {
+			active = false;
+			observable.beacon.observers.delete(instance);
+		}
+	}
+	let active = true;
+	const instance = {
+		close: () => {
+			unsubscribe();
+		},
+		unsubscribe: () => {
+			unsubscribe();
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_BEACON]: {
+			enumerable: false,
+			value: NAME_SUBSCRIPTION
+		},
+		active: {
+			enumerable: true,
+			get: () => observable.beacon.active && observable.active && active
+		},
+		closed: {
+			enumerable: true,
+			get: () => !observable.beacon.active || !observable.active || !active
+		}
+	});
+	return Object.freeze(instance);
+}
+function update$1(type, state, value, finish) {
+	if (!state.active) return;
+	if (type === TYPE_NEXT) {
+		if (state.options.equal(state.value, value)) return;
+		state.value = value;
+	}
+	for (const [, observer] of state.observers) observer[type]?.(value);
+	if (finish === true) finishBeacon(state, true);
+}
+const KEY_BEACON = "$beacon";
+const MESSAGE_BEACON = "Cannot retrieve observable from a closed beacon";
+const MESSAGE_OBSERVABLE = "Cannot subscribe to a closed observable";
+const NAME_BEACON = "beacon";
+const NAME_OBSERVABLE = "observable";
+const NAME_SUBSCRIPTION = "subscription";
 const TYPE_ERROR = "error";
 const TYPE_NEXT = "next";
 //#endregion
+//#region src/color/misc/index.ts
+function formatHslColor(state, alpha) {
+	const { hue, lightness, saturation } = state.hsl;
+	return `hsl(${hue}deg ${saturation}% ${lightness}%${alpha ? ` / ${state.alpha.value}%` : ""})`;
+}
+function formatHwbColor(state, alpha) {
+	const { blackness, hue, whiteness } = state.hwb;
+	return `hwb(${hue}deg ${whiteness}% ${blackness}%${alpha ? ` / ${state.alpha.value}%` : ""})`;
+}
+function formatRgbColor(state, alpha) {
+	const { blue, green, red } = state.rgb;
+	return `rgb(${red} ${green} ${blue}${alpha ? ` / ${state.alpha.value}%` : ""})`;
+}
+//#endregion
 //#region src/internal/math/misc.ts
 /**
 * Round a number
@@ -4081,20 +4046,6 @@ function roundNumber(callback, value, decimals) {
 	const mod = 10 ** decimals;
 	return callback((value + Number.EPSILON) * mod) / mod;
 }
-//#endregion
-//#region src/color/misc/index.ts
-function formatHslColor(color, alpha) {
-	const { hue, lightness, saturation } = color.hsl;
-	return `hsl(${hue}deg ${saturation}% ${lightness}%${alpha ? ` / ${color.alpha}%` : ""})`;
-}
-function formatHwbColor(color, alpha) {
-	const { blackness, hue, whiteness } = color.hwb;
-	return `hwb(${hue}deg ${whiteness}% ${blackness}%${alpha ? ` / ${color.alpha}%` : ""})`;
-}
-function formatRgbColor(color, alpha) {
-	const { blue, green, red } = color.rgb;
-	return `rgb(${red} ${green} ${blue}${alpha ? ` / ${color.alpha}%` : ""})`;
-}
 const ALPHA_FULL_HEX_LONG = `ff`;
 const DEFAULT_ALPHA = {
 	hex: ALPHA_FULL_HEX_LONG,
@@ -4186,8 +4137,8 @@ function getForegroundColor(value, hex) {
 		if (color <= .03928) values[index] /= SRGB_LUMINANCE_MULTIPLIER;
 		else values[index] = ((color + SRGB_LUMINANCE_OFFSET) / SRGB_LUMINANCE_MODIFIER) ** SRGB_LUMINANCE_EXPONENT;
 	}
-	const color = .2126 * values[2] + .7152 * values[1] + .0722 * values[0] > .625 ? HEX_BLACK : HEX_WHITE;
-	return hex === true ? color : new Color(color);
+	const foreground = .2126 * values[2] + .7152 * values[1] + .0722 * values[0] > .625 ? HEX_BLACK : HEX_WHITE;
+	return hex === true ? foreground : color(foreground);
 }
 /**
 * Get the hex color _(with alpha channel, i.e., opacity)_ from any kind of value
@@ -4360,7 +4311,10 @@ function isDegree(value) {
 function isHexColor(value, alpha) {
 	if (typeof value !== "string") return false;
 	if (!(EXPRESSION_HEX_SHORT.test(value) || EXPRESSION_HEX_LONG.test(value))) return false;
-	if (alpha === false) return value.length === 3 || value.length === 6;
+	if (alpha === false) {
+		const unprefixed = value.replace(EXPRESSION_PREFIX, "");
+		return unprefixed.length === 3 || unprefixed.length === 6;
+	}
 	return true;
 }
 /**
@@ -5047,222 +5001,63 @@ function setRGBColor(state, value, alpha) {
 }
 //#endregion
 //#region src/color/instance.ts
-/**
-* A color that is represented in multiple color formats
-*/
-var Color = class {
-	#state;
-	/**
-	* Get the alpha channel _(opacity)_ of the color as a percentage between `0` and `100`
-	*
-	* @returns Current alpha channel value
-	*/
-	get alpha() {
-		return this.#state.alpha.value;
-	}
-	/**
-	* Set the alpha channel _(opacity)_ of the color as a percentage between `0` and `100`
-	*
-	* @param value New alpha channel value
-	*/
-	set alpha(value) {
-		if (typeof value === "number" && !Number.isNaN(value)) this.#state.alpha = getAlpha(value);
-	}
-	/**
-	* Get the color as a hex color string
-	*
-	* _Hex color string is returned with no `#`-prefix or alpha channel (opacity)_
-	*
-	* @returns Current color as a hex color string
-	*/
-	get hex() {
-		return this.#state.hex;
-	}
-	/**
-	* Set the color from a hex color string
-	*
-	* - `#`-prefix is optional
-	* - Alpha channel _(opacity)_ will be ignored
-	*
-	* @param value New hex color string
-	*/
-	set hex(value) {
-		setHexColor(this.#state, value, false);
-	}
-	/**
-	* Get the color as a hex color with an alpha channel _(opacity)_
-	*
-	* _Hex color string is returned with alpha channel (opacity), but without `#`-prefix_
-	*
-	* @returns Current color as a hex color string
-	*/
-	get hexa() {
-		return `${this.#state.hex}${this.#state.alpha.hex}`;
-	}
-	/**
-	* Set the color from a hex color string with an alpha channel _(opacity)_
-	*
-	* - `#`-prefix is optional
-	* - Alpha channel _(opacity)_ will be respected
-	*
-	* @param value New hex color string
-	*/
-	set hexa(value) {
-		setHexColor(this.#state, value, true);
-	}
-	/**
-	* Get the color as an _HSL_ color
-	*
-	* @returns Current color as an _HSL_ color
-	*/
-	get hsl() {
-		return { ...this.#state.hsl };
-	}
-	/**
-	* Set colors from an _HSL_ color
-	*
-	* @param value New _HSL_ color
-	*/
-	set hsl(value) {
-		setHSLColor(this.#state, value, false);
-	}
-	/**
-	* Get the color as an _HSLA_ color
-	*
-	* @returns Current color as an _HSLA_ color
-	*/
-	get hsla() {
-		return {
-			...this.#state.hsl,
-			alpha: this.#state.alpha.value
-		};
-	}
-	/**
-	* Set colors and alpha from an _HSLA_ color
-	*
-	* @param value New _HSLA_ color
-	*/
-	set hsla(value) {
-		setHSLColor(this.#state, value, true);
-	}
-	/**
-	* Get the color as an _HWB_ color
-	*
-	* @returns Current color as an _HWB_ color
-	*/
-	get hwb() {
-		return { ...this.#state.hwb };
-	}
-	/**
-	* Set colors from an _HWB_ color
-	*
-	* @param value New _HWB_ color
-	*/
-	set hwb(value) {
-		setHWBColor(this.#state, value, false);
-	}
-	/**
-	* Get the color as an _HWBA_ color
-	*
-	* @returns Current color as an _HWBA_ color
-	*/
-	get hwba() {
-		return {
-			...this.#state.hwb,
-			alpha: this.#state.alpha.value
-		};
-	}
-	/**
-	* Set colors and alpha from an _HWBA_ color
-	*
-	* @param value New _HWBA_ color
-	*/
-	set hwba(value) {
-		setHWBColor(this.#state, value, true);
-	}
-	/**
-	* Get the color as an _RGB_ color
-	*
-	* @returns Current color as an _RGB_ color
-	*/
-	get rgb() {
-		return { ...this.#state.rgb };
-	}
-	/**
-	* Set colors from an _RGB_ color
-	*
-	* @param value New _RGB_ color
-	*/
-	set rgb(value) {
-		setRGBColor(this.#state, value, false);
-	}
-	/**
-	* Get the color as an _RGBA_ color
-	*
-	* @returns Current color as an _RGBA_ color
-	*/
-	get rgba() {
-		return {
-			...this.#state.rgb,
-			alpha: this.#state.alpha.value
-		};
-	}
-	/**
-	* Set colors and alpha from an _RGBA_ color
-	*
-	* @param value New _RGBA_ color
-	*/
-	set rgba(value) {
-		setRGBColor(this.#state, value, true);
-	}
-	constructor(value) {
-		this.#state = getColorState(value);
-		Object.defineProperty(this, "$color", { value: true });
-	}
-	/**
-	* Get the color as a hex string
-	*
-	* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
-	* @returns Hex color string
-	*/
-	toHexString(alpha) {
-		return `#${alpha === true ? this.hexa : this.hex}`;
-	}
-	/**
-	* Get the color as an _HSL(A)_ string
-	*
-	* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
-	* @returns _HSL(A)_ color string
-	*/
-	toHslString(alpha) {
-		return formatHslColor(this, alpha === true);
-	}
-	/**
-	* Get the color as an _HWB(A)_ string
-	*
-	* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
-	* @returns _HWB(A)_ color string
-	*/
-	toHwbString(alpha) {
-		return formatHwbColor(this, alpha === true);
-	}
-	/**
-	* Get the color as an _RGB(A)_ string
-	*
-	* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
-	* @returns _RGB(A)_ color string
-	*/
-	toRgbString(alpha) {
-		return formatRgbColor(this, alpha === true);
-	}
-	/**
-	* Get the color as a hex color string
-	*
-	* @returns Hex color string
-	*/
-	toString() {
-		return this.toHexString();
-	}
+function color(value) {
+	const state = getColorState(value);
+	const instance = {
+		toHexString: (alpha) => `#${alpha === true ? instance.hexa : instance.hex}`,
+		toHslString: (alpha) => formatHslColor(state, alpha === true),
+		toHwbString: (alpha) => formatHwbColor(state, alpha === true),
+		toRgbString: (alpha) => formatRgbColor(state, alpha === true),
+		toString: () => instance.toHexString()
+	};
+	Object.defineProperties(instance, {
+		$color: {
+			enumerable: false,
+			get: () => true
+		},
+		alpha: {
+			enumerable: true,
+			get: () => state.alpha.value,
+			set: (value) => {
+				if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value);
+			}
+		},
+		hex: getProperty("hex", state, false),
+		hexa: getProperty("hex", state, true),
+		hsl: getProperty("hsl", state, false),
+		hsla: getProperty("hsl", state, true),
+		hwb: getProperty("hwb", state, false),
+		hwba: getProperty("hwb", state, true),
+		rgb: getProperty("rgb", state, false),
+		rgba: getProperty("rgb", state, true)
+	});
+	return Object.freeze(instance);
+}
+function getHex(state, alpha) {
+	return alpha ? `${state.hex}${state.alpha.hex}` : state.hex;
+}
+function getProperty(space, state, alpha) {
+	const setter = setters[space];
+	return {
+		enumerable: true,
+		get: () => {
+			const value = state[space];
+			if (typeof value === "string") return getHex(state, alpha);
+			return alpha ? {
+				...value,
+				alpha: state.alpha.value
+			} : { ...value };
+		},
+		set: (value) => {
+			setter(state, value, alpha);
+		}
+	};
+}
+const setters = {
+	hex: setHexColor,
+	hsl: setHSLColor,
+	hwb: setHWBColor,
+	rgb: setRGBColor
 };
 //#endregion
 //#region src/color/index.ts
@@ -5276,55 +5071,65 @@ var Color = class {
 * @returns _Color_ instance
 */
 function getColor(value) {
-	return isColor(value) ? value : new Color(value);
+	return isColor(value) ? value : color(value);
 }
 //#endregion
 //#region src/logger.ts
-/**
-* A named timer that can be used to log durations to the console
-*/
-var TimedLogger = class {
-	#logger;
-	#stopper;
-	#state;
-	/**
-	* Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
-	*/
-	get active() {
-		return this.#state.started && !this.#state.stopped && enabled;
-	}
-	/**
-	* Log the current duration of the timer _(ignored if logging is disabled)_
-	*/
-	get log() {
-		return this.active ? this.#logger : noop;
-	}
-	/**
-	* Stop the timer and logs the total duration
-	*
-	* _(Will always log the total duration, even if logging is disabled)_
-	*/
-	get stop() {
-		return this.active ? this.#stopTimer() : noop;
-	}
-	constructor(label) {
-		this.#logger = console.timeLog.bind(console, label);
-		this.#stopper = console.timeEnd.bind(console, label);
-		this.#state = {
-			label,
-			started: enabled,
-			stopped: false
-		};
-		if (this.#state.started) console.time(label);
-	}
-	#stopTimer() {
-		const stopper = this.#stopper;
-		this.#state.stopped = true;
-		this.#logger = void 0;
-		this.#stopper = void 0;
-		return stopper;
+function isLogger(value) {
+	return isLoggerInstance(NAME_LOGGER, value);
+}
+function isLoggerInstance(name, value) {
+	return typeof value === "object" && value !== null && value[KEY_LOGGER] === name;
+}
+function isTimedLogger(value) {
+	return isLoggerInstance(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, {
+		[KEY_LOGGER]: {
+			enumerable: false,
+			value: NAME_TIMED
+		},
+		active: {
+			enumerable: true,
+			get() {
+				return state.started && !state.stopped && enabled;
+			}
+		},
+		log: {
+			enumerable: true,
+			get() {
+				return this.active ? logger : noop;
+			}
+		},
+		stop: {
+			enumerable: true,
+			get() {
+				return 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 methods = [
 	"debug",
 	"dir",
@@ -5343,7 +5148,12 @@ const methods = [
 const Logger = (() => {
 	const instance = {};
 	Object.defineProperties(instance, {
+		[KEY_LOGGER]: {
+			enumerable: false,
+			value: NAME_LOGGER
+		},
 		enabled: {
+			enumerable: true,
 			get() {
 				return enabled;
 			},
@@ -5351,13 +5161,19 @@ const Logger = (() => {
 				enabled = typeof value === "boolean" ? value : enabled;
 			}
 		},
-		time: { value(label) {
-			return new TimedLogger(label);
-		} }
+		time: {
+			enumerable: true,
+			value(label) {
+				return timedLogger(label);
+			}
+		}
+	});
+	for (const method of methods) Object.defineProperty(instance, method, {
+		enumerable: true,
+		get() {
+			return enabled ? console[method].bind(console) : noop;
+		}
 	});
-	for (const method of methods) Object.defineProperty(instance, method, { get() {
-		return enabled ? console[method].bind(console) : noop;
-	} });
 	return Object.freeze(instance);
 })();
 let enabled = true;
@@ -5501,7 +5317,7 @@ function getStrategyOrDefault(value) {
 * Is the value a fulfilled _Promise_ result?
 *
 * @param value Value to check
-* @returns `true` if the value is a fulfilled _Promise_ result, `false` otherwise
+* @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
 */
 function isFulfilled(value) {
 	return isType(value, PROMISE_TYPE_FULFILLED);
@@ -5510,7 +5326,7 @@ function isFulfilled(value) {
 * Is the value a rejected _Promise_ result?
 *
 * @param value Value to check
-* @returns `true` if the value is a rejected _Promise_ result, `false` otherwise
+* @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
 */
 function isRejected(value) {
 	return isType(value, PROMISE_TYPE_REJECTED);
@@ -5761,345 +5577,6 @@ const TYPES = /* @__PURE__ */ new Set([
 //#endregion
 //#region src/queue.ts
 /**
-* A queue that can be used to manage (a)synchronous tasks with a specific key
-*/
-var KeyedQueue = class {
-	#callback;
-	#options;
-	#queues = /* @__PURE__ */ new Map();
-	/**
-	* Get keys of all active queues
-	*/
-	get active() {
-		return this.#getStatus(STATUS_ACTIVE);
-	}
-	/**
-	* Does the queue automatically start when the first item is added?
-	*/
-	get autostart() {
-		return this.#options.autostart;
-	}
-	/**
-	* Maximum number of runners to process the queue concurrently
-	*/
-	get concurrency() {
-		return this.#options.concurrency;
-	}
-	/**
-	* Get keys of all empty queues
-	*/
-	get empty() {
-		return this.#getStatus(STATUS_EMPTY);
-	}
-	/**
-	* Get keys of all full queues
-	*/
-	get full() {
-		return this.#getStatus(STATUS_FULL);
-	}
-	/**
-	* Number of items in all queues
-	*/
-	get items() {
-		const size = {};
-		const queues = this.#queues.entries();
-		for (const [key, queue] of queues) size[key] = queue.size;
-		return size;
-	}
-	/**
-	* Keys of all queues
-	*/
-	get keys() {
-		return [...this.#queues.keys()];
-	}
-	/**
-	* Maximum number of items allowed in the queue
-	*/
-	get maximum() {
-		return this.#options.maximum;
-	}
-	/**
-	* Are all queues paused?
-	*/
-	get paused() {
-		return this.#getStatus(STATUS_PAUSED);
-	}
-	/**
-	* Number of queues
-	*/
-	get queues() {
-		return this.#queues.size;
-	}
-	constructor(callback, options) {
-		this.#callback = callback;
-		this.#options = options;
-	}
-	/**
-	* Queue an item for a specific key
-	*
-	* @param key Key to queue the item for
-	* @param parameters Parameters to use when item runs
-	* @param signal Optional signal to abort the item
-	* @returns Queued item
-	*/
-	add(key, parameters, signal) {
-		return this.#getQueue(key, true).add(parameters, signal);
-	}
-	/**
-	* Clear all items for a specific key _(or all items for all keys, if no key is provided)_
-	*
-	* @param key Optional key to clear the queue for
-	*/
-	clear(key) {
-		this.#handleQueues(HANDLE_CLEAR, key);
-	}
-	/**
-	* Get the queue for a specific key
-	*
-	* @param key Key to get the queue for
-	* @returns Queue for the key, or `undefined` if it doesn't exist
-	*/
-	get(key) {
-		return this.#getQueue(key);
-	}
-	/**
-	* Pause the queue for a specific key _(or all queues, if no key is provided)_
-	*
-	* @param key Optional key to pause the queue for
-	*/
-	pause(key) {
-		this.#handleQueues(HANDLE_PAUSE, key);
-	}
-	remove(key, id) {
-		if (key == null) {
-			this.#handleQueues(HANDLE_CLEAR);
-			this.#queues.clear();
-			return;
-		}
-		const queue = this.#getQueue(key);
-		if (queue == null) return;
-		if (typeof id === "number") {
-			queue.remove(id);
-			return;
-		}
-		queue.clear();
-		this.#queues.delete(key);
-	}
-	/**
-	* Resume the queue for a specific key _(or all queues, if no key is provided)_
-	*
-	* @param key Optional key to resume the queue for
-	*/
-	resume(key) {
-		this.#handleQueues(HANDLE_RESUME, key);
-	}
-	#getQueue(key, add) {
-		if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
-		let queue = this.#queues.get(key);
-		if (queue == null && add === true) {
-			queue = new Queue(this.#callback, this.#options, key);
-			this.#queues.set(key, queue);
-		}
-		return queue;
-	}
-	#getStatus(status) {
-		const queues = this.#queues.entries();
-		const result = [];
-		for (const [key, queue] of queues) if (queue[status]) result.push(key);
-		return result;
-	}
-	#handleQueues(type, key) {
-		if (typeof key === "string") {
-			this.#getQueue(key)?.[type]();
-			return;
-		}
-		const queues = this.#queues.values();
-		for (const queue of queues) queue[type]();
-	}
-};
-/**
-* A queue that can be used to manage (a)synchronous tasks
-*/
-var Queue = class {
-	#callback;
-	#handled = [];
-	#id = 0;
-	#items = [];
-	#key;
-	#options;
-	#paused;
-	#runners = 0;
-	/**
-	* Is the queue active?
-	*/
-	get active() {
-		return this.#runners > 0;
-	}
-	/**
-	* Does the queue automatically start when the first item is added?
-	*/
-	get autostart() {
-		return this.#options.autostart;
-	}
-	/**
-	* Maximum number of runners to process the queue concurrently
-	*/
-	get concurrency() {
-		return this.#options.concurrency;
-	}
-	/**
-	* Is the queue empty?
-	*/
-	get empty() {
-		return this.#items.length === 0;
-	}
-	/**
-	* Is the queue full?
-	*/
-	get full() {
-		return this.#options.maximum > 0 && this.#items.length >= this.#options.maximum;
-	}
-	/**
-	* Maximum number of items allowed in the queue
-	*/
-	get maximum() {
-		return this.#options.maximum;
-	}
-	/**
-	* Is the queue paused?
-	*/
-	get paused() {
-		return this.#paused;
-	}
-	/**
-	* Number of items in the queue
-	*/
-	get size() {
-		return this.#items.length;
-	}
-	constructor(callback, options, key) {
-		this.#callback = callback;
-		this.#key = key;
-		this.#options = options;
-		this.#paused = !options.autostart;
-	}
-	/**
-	* Add an item to the queue
-	*
-	* @param parameters Parameters to use when item runs
-	* @param signal Optional signal to abort the item
-	* @returns Queued item
-	*/
-	add(parameters, signal) {
-		if (this.full) throw new QueueError(MESSAGE_MAXIMUM);
-		const abortSignal = signal instanceof AbortSignal ? signal : void 0;
-		if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
-		const id = this.#identify();
-		let rejector;
-		let resolver;
-		const promise = new Promise((resolve, reject) => {
-			rejector = reject;
-			resolver = resolve;
-		});
-		const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
-		signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
-		this.#items.push({
-			id,
-			parameters,
-			promise,
-			abort: aborter,
-			key: this.#key,
-			reject: rejector,
-			resolve: resolver,
-			signal: abortSignal
-		});
-		if (this.#options.autostart) this.#run();
-		return {
-			id,
-			promise
-		};
-	}
-	/**
-	* Remove and reject all items in the queue
-	*/
-	clear() {
-		const items = this.#items.splice(0);
-		const { length } = items;
-		for (let index = 0; index < length; index += 1) {
-			const { abort, reject, signal } = items[index];
-			reject(new QueueError(MESSAGE_CLEAR));
-			signal?.removeEventListener(EVENT_NAME, abort);
-		}
-	}
-	/**
-	* Pause the queue
-	*
-	* - Currently running items will not be stopped
-	* - New added items will not run until the queue is resumed
-	*/
-	pause() {
-		this.#paused = true;
-	}
-	/**
-	* Remove and reject a specific item in the queue
-	*
-	* @param id ID of queued item
-	*/
-	remove(id) {
-		const index = this.#items.findIndex((item) => item.id === id);
-		if (index > -1) {
-			const { abort, reject, signal } = this.#items.splice(index, 1)[0];
-			reject(new QueueError(MESSAGE_REMOVE));
-			signal?.removeEventListener(EVENT_NAME, abort);
-		}
-	}
-	/**
-	* Resume the queue
-	*/
-	resume() {
-		if (this.#paused) {
-			const handled = this.#handled.splice(0);
-			const { length } = handled;
-			for (let index = 0; index < length; index += 1) handled[index]();
-		}
-		this.#paused = false;
-		const length = Math.min(this.#options.concurrency, this.#items.length);
-		for (let index = 0; index < length; index += 1) this.#run();
-	}
-	#identify() {
-		this.#id += 1;
-		return this.#id;
-	}
-	async #run() {
-		if (this.#paused || this.#runners >= this.#options.concurrency) return;
-		this.#runners += 1;
-		let item = this.#items.shift();
-		while (item != null) {
-			let error = false;
-			let result;
-			try {
-				if (!(item.signal?.aborted ?? false)) {
-					const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
-					result = await this.#callback(...parameters);
-				}
-			} catch (thrown) {
-				error = true;
-				result = thrown;
-			}
-			if (this.#paused) {
-				const paused = item;
-				this.#handled.push(() => {
-					handleQueuedResult(paused, error, result, this.#items.length === 0);
-				});
-				break;
-			}
-			handleQueuedResult(item, error, result, this.#items.length === 0);
-			item = this.#items.shift();
-		}
-		this.#runners -= 1;
-	}
-};
-/**
 * An error thrown by the Queue when an operation fails
 */
 var QueueError = class extends Error {
@@ -6108,6 +5585,119 @@ var QueueError = class extends Error {
 		this.name = ERROR_NAME;
 	}
 };
+function createQueue(callback, options, key) {
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	const state = {
+		callback,
+		key,
+		handled: [],
+		id: 0,
+		items: [],
+		options: getOptions(options),
+		paused: !getBooleanOrDefault(options?.autostart, true),
+		runners: 0
+	};
+	const instance = {
+		add: (parameters, signal) => {
+			if (instance.full) throw new QueueError(MESSAGE_MAXIMUM);
+			const abortSignal = signal instanceof AbortSignal ? signal : void 0;
+			if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
+			const id = identify(state);
+			let rejector;
+			let resolver;
+			const promise = new Promise((resolve, reject) => {
+				rejector = reject;
+				resolver = resolve;
+			});
+			const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
+			signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
+			state.items.push({
+				id,
+				parameters,
+				promise,
+				abort: aborter,
+				key: state.key,
+				reject: rejector,
+				resolve: resolver,
+				signal: abortSignal
+			});
+			if (state.options.autostart) run(state);
+			return {
+				id,
+				promise
+			};
+		},
+		clear: () => {
+			const items = state.items.splice(0);
+			const { length } = items;
+			for (let index = 0; index < length; index += 1) {
+				const { abort, reject, signal } = items[index];
+				reject(new QueueError(MESSAGE_CLEAR));
+				signal?.removeEventListener(EVENT_NAME, abort);
+			}
+		},
+		pause: () => {
+			state.paused = true;
+		},
+		remove: (id) => {
+			const index = state.items.findIndex((item) => item.id === id);
+			if (index > -1) {
+				const { abort, reject, signal } = state.items.splice(index, 1)[0];
+				reject(new QueueError(MESSAGE_REMOVE));
+				signal?.removeEventListener(EVENT_NAME, abort);
+			}
+		},
+		resume: () => {
+			if (state.paused) {
+				const handled = state.handled.splice(0);
+				const { length } = handled;
+				for (let index = 0; index < length; index += 1) handled[index]();
+			}
+			state.paused = false;
+			const length = Math.min(state.options.concurrency, state.items.length);
+			for (let index = 0; index < length; index += 1) run(state);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_QUEUE]: {
+			enumerable: false,
+			value: NAME_QUEUE
+		},
+		active: {
+			enumerable: true,
+			get: () => state.runners > 0
+		},
+		autostart: {
+			enumerable: true,
+			get: () => state.options.autostart
+		},
+		concurrency: {
+			enumerable: true,
+			get: () => state.options.concurrency
+		},
+		empty: {
+			enumerable: true,
+			get: () => state.items.length === 0
+		},
+		full: {
+			enumerable: true,
+			get: () => state.options.maximum > 0 && state.items.length >= state.options.maximum
+		},
+		maximum: {
+			enumerable: true,
+			get: () => state.options.maximum
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.paused
+		},
+		size: {
+			enumerable: true,
+			get: () => state.items.length
+		}
+	});
+	return Object.freeze(instance);
+}
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
@@ -6119,27 +5709,193 @@ function getOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
+function getQueue(state, key, add) {
+	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
+	let queue = state.queues.get(key);
+	if (queue == null && add === true) {
+		queue = createQueue(state.callback, state.options, key);
+		state.queues.set(key, queue);
+	}
+	return queue;
+}
+function getStatus(state, status) {
+	const queues = state.queues.entries();
+	const result = [];
+	for (const [key, queue] of queues) if (queue[status]) result.push(key);
+	return result;
+}
 function handleQueuedResult(item, error, result, finished) {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort);
-	if (item.signal?.aborted ?? false) item.reject();
-	else if (error) item.reject(result);
-	else item.resolve({
+	if (item.signal?.aborted ?? false) {
+		item.reject();
+		return;
+	}
+	if (error) {
+		item.reject(result);
+		return;
+	}
+	item.resolve({
 		finished,
 		value: result
 	});
 }
+function handleQueues(state, type, key) {
+	if (typeof key === "string") {
+		getQueue(state, key)?.[type]();
+		return;
+	}
+	const queues = state.queues.values();
+	for (const queue of queues) queue[type]();
+}
+function identify(state) {
+	state.id += 1;
+	return state.id;
+}
+/**
+* Is the value keyed queue?
+*
+* @param value Value to check
+* @returns `true` if the value is a keyed queue, otherwise `false`
+*/
+function isKeyedQueue(value) {
+	return isQueueInstance(NAME_KEYED, value);
+}
+/**
+* Is the value a queue?
+*
+* @param value Value to check
+* @returns `true` if the value is a queue, otherwise `false`
+*/
+function isQueue(value) {
+	return isQueueInstance(NAME_QUEUE, value);
+}
+function isQueueInstance(name, value) {
+	return typeof value === "object" && value != null && value[KEY_QUEUE] === name;
+}
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
-	return new KeyedQueue(callback, getOptions(options));
+	const state = {
+		callback,
+		options: getOptions(options),
+		queues: /* @__PURE__ */ new Map()
+	};
+	const instance = {
+		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
+		clear: (key) => {
+			handleQueues(state, HANDLE_CLEAR, key);
+		},
+		get: (key) => getQueue(state, key),
+		pause: (key) => {
+			handleQueues(state, HANDLE_PAUSE, key);
+		},
+		remove: (key, id) => {
+			if (key == null) {
+				handleQueues(state, HANDLE_CLEAR);
+				state.queues.clear();
+				return;
+			}
+			const queue = getQueue(state, key);
+			if (queue == null) return;
+			if (typeof id === "number") {
+				queue.remove(id);
+				return;
+			}
+			queue.clear();
+			state.queues.delete(key);
+		},
+		resume: (key) => {
+			handleQueues(state, HANDLE_RESUME, key);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_QUEUE]: {
+			enumerable: false,
+			value: NAME_KEYED
+		},
+		active: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_ACTIVE)
+		},
+		autostart: {
+			enumerable: true,
+			get: () => state.options.autostart
+		},
+		concurrency: {
+			enumerable: true,
+			get: () => state.options.concurrency
+		},
+		empty: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_EMPTY)
+		},
+		full: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_FULL)
+		},
+		items: {
+			enumerable: true,
+			get: () => {
+				const size = {};
+				const queues = state.queues.entries();
+				for (const [key, queue] of queues) size[key] = queue.size;
+				return size;
+			}
+		},
+		keys: {
+			enumerable: true,
+			get: () => [...state.queues.keys()]
+		},
+		maximum: {
+			enumerable: true,
+			get: () => state.options.maximum
+		},
+		paused: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_PAUSED)
+		},
+		queues: {
+			enumerable: true,
+			get: () => state.queues.size
+		}
+	});
+	return Object.freeze(instance);
 }
 function queue(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
-	return new Queue(callback, getOptions(options));
+	return createQueue(callback, options);
 }
 queue.keyed = keyedQueue;
+async function run(state) {
+	if (state.paused || state.runners >= state.options.concurrency) return;
+	state.runners += 1;
+	let item = state.items.shift();
+	while (item != null) {
+		let error = false;
+		let result;
+		try {
+			if (!(item.signal?.aborted ?? false)) {
+				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
+				result = await state.callback(...parameters);
+			}
+		} catch (thrown) {
+			error = true;
+			result = thrown;
+		}
+		if (state.paused) {
+			const paused = item;
+			state.handled.push(() => {
+				handleQueuedResult(paused, error, result, state.items.length === 0);
+			});
+			break;
+		}
+		handleQueuedResult(item, error, result, state.items.length === 0);
+		item = state.items.shift();
+	}
+	state.runners -= 1;
+}
 const ERROR_NAME = "QueueError";
 const EVENT_NAME = "abort";
 const EVENT_OPTIONS = { once: true };
+const KEY_QUEUE = "$queue";
 const HANDLE_CLEAR = "clear";
 const HANDLE_PAUSE = "pause";
 const HANDLE_RESUME = "resume";
@@ -6148,6 +5904,8 @@ const MESSAGE_CLEAR = "Queue was cleared";
 const MESSAGE_KEY = "Key must be a non-empty string";
 const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
 const MESSAGE_REMOVE = "Item removed from queue";
+const NAME_KEYED = "keyedQueue";
+const NAME_QUEUE = "queue";
 const STATUS_ACTIVE = "active";
 const STATUS_EMPTY = "empty";
 const STATUS_FULL = "full";
@@ -6356,4 +6114,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isColor, isConstructor, isEmpty, isError, isEvents, isFrozen, isFulfilled, isHerald, isHexColor, isHslColor, isHslLike, isHslaColor, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };