@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/promise/models.d.mts

@@ -6,7 +6,7 @@ import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 /**
  * A _Promise_ that can be canceled
  */
-declare class CancelablePromise<Value = void> extends Promise<Value> {
+export declare class CancelablePromise<Value = void> extends Promise<Value> {
   #private;
   constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
   /**
@@ -19,7 +19,7 @@ declare class CancelablePromise<Value = void> extends Promise<Value> {
 /**
  * A _Promise_ that was fulfilled
  */
-type FulfilledPromise<Value> = {
+export type FulfilledPromise<Value> = {
   /**
    * Status of the _Promise_
    */
@@ -29,18 +29,18 @@ type FulfilledPromise<Value> = {
    */
   value: Awaited<Value>;
 };
-type PromiseData = {
+export type PromiseData = {
   last: number;
   result: ArrayOrPlainObject;
 };
-type PromiseHandlers = {
+export type PromiseHandlers = {
   resolve: (value: unknown[]) => void;
   reject: (reason: unknown) => void;
 };
 /**
  * Options for a _Promise_-handling function
  */
-type PromiseOptions = {
+export type PromiseOptions = {
   /**
    * AbortSignal for aborting the _Promise_; when aborted, the _Promise_ will reject with the reason of the signal
    */
@@ -50,7 +50,7 @@ type PromiseOptions = {
    */
   time?: number;
 };
-type PromiseParameters = {
+export type PromiseParameters = {
   aborter?: Aborter;
   complete: boolean;
   data: PromiseData;
@@ -65,18 +65,18 @@ type PromiseParameters = {
  * - `complete`: wait for all _Promises_ to settle, then return the results, as an array of fulfilled and/or rejected results
  * - `first`: rejects on the first rejected _Promise_, and returns an array of values
  */
-type PromiseStrategy = 'complete' | 'first';
+export type PromiseStrategy = 'complete' | 'first';
 /**
  * An error thrown when a promise times out
  */
-declare class PromiseTimeoutError extends Error {
+export declare class PromiseTimeoutError extends Error {
   constructor();
 }
-type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
+export type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
 /**
  * Options for handling multiple _Promises_
  */
-type PromisesOptions = {
+export type PromisesOptions = {
   /**
    * AbortSignal for aborting the _Promises_; when aborted, the _Promises_ will reject with the reason of the signal
    */
@@ -86,14 +86,14 @@ type PromisesOptions = {
    */
   strategy?: PromiseStrategy;
 };
-type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
-type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
+export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
+export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
+export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
+export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
 /**
  * A _Promise_ that was rejected
  */
-type RejectedPromise = {
+export type RejectedPromise = {
   /**
    * Status of the _Promise_
    */
@@ -103,5 +103,4 @@ type RejectedPromise = {
    */
   reason: unknown;
 };
-//#endregion
-export { CancelablePromise, FulfilledPromise, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, RejectedPromise };
+//#endregion

package/dist/promise/timed.d.mts

@@ -1,7 +1,7 @@
 import { RequiredKeys } from "../models.mjs";
 import { PromiseOptions } from "./models.mjs";
 //#region src/promise/timed.d.ts
-declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
+export declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
 /**
  * Create a _Promise_ that should be settled within a certain amount of time
  *
@@ -9,7 +9,7 @@ declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, s
  * @param options Timed options
  * @returns Timed _Promise_
  */
-declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, 'time'>): Promise<Value>;
+export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, 'time'>): Promise<Value>;
 /**
  * Create a _Promise_ that should be settled within a certain amount of time
  *
@@ -17,6 +17,5 @@ declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<Pro
  * @param time How long to wait for _(in milliseconds; defaults to `0`)_
  * @returns Timed _Promise_
  */
-declare function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;
-//#endregion
-export { getTimedPromise, timed };
+export declare function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;
+//#endregion

package/dist/promise/timed.mjs

@@ -1,5 +1,5 @@
 import { createAborter } from "../internal/abort.mjs";
-import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
+import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
 import { PROMISE_MESSAGE_EXPECTATION_TIMED } from "./constants.mjs";
 import { PromiseTimeoutError } from "./models.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
@@ -7,17 +7,17 @@ import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
 	const aborter = createAborter(signal, () => {
-		timer.cancel();
+		limiter.cancel();
 		rejector(signal?.reason);
 	});
-	const timer = getTimer(TIMER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
+	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
 	let rejector;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
-		timer();
+		limiter.run();
 	})]).then((value) => {
 		aborter?.cancel();
-		timer.cancel();
+		limiter.cancel();
 		rejector(void 0);
 		return value;
 	});

package/dist/query.d.mts

@@ -6,13 +6,12 @@ import { PlainObject } from "./models.mjs";
  * @param query Query string to convert
  * @returns Plain object representation of the query string
  */
-declare function fromQuery(query: string): PlainObject;
+export declare function fromQuery(query: string): PlainObject;
 /**
  * Convert a plain _(nested)_ object to a query string
  *
  * @param parameters Plain object to convert
  * @returns Query string representation of the object
  */
-declare function toQuery(parameters: PlainObject): string;
-//#endregion
-export { fromQuery, toQuery };
+export declare function toQuery(parameters: PlainObject): string;
+//#endregion

package/dist/queue.d.mts

@@ -3,7 +3,7 @@ import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
 /**
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
-type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
+export type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Get keys of all active queues
    */
@@ -101,7 +101,7 @@ type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, Callbac
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
+export type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Is the queue active?
    */
@@ -167,10 +167,10 @@ type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackPara
 /**
  * An error thrown by the Queue when an operation fails
  */
-declare class QueueError extends Error {
+export declare class QueueError extends Error {
   constructor(message: string);
 }
-type QueueOptions = {
+export type QueueOptions = {
   /**
    * Automatically start processing the queue when the first item is added _(defaults to `true`)_
    */
@@ -187,7 +187,7 @@ type QueueOptions = {
 /**
  * A queued item
  */
-type Queued<Value> = {
+export type Queued<Value> = {
   /**
    * ID of the queued item _(can be used to remove it from the queue)_
    */
@@ -204,15 +204,15 @@ type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest
  * @param value Value to check
  * @returns `true` if the value is a keyed queue, otherwise `false`
  */
-declare function isKeyedQueue(value: unknown): value is KeyedQueue<GenericAsyncCallback>;
+export declare function isKeyedQueue(value: unknown): value is KeyedQueue<GenericAsyncCallback>;
 /**
  * Is the value a queue?
  *
  * @param value Value to check
  * @returns `true` if the value is a queue, otherwise `false`
  */
-declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
-declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
+export declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
+export declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
 /**
  * Create a keyed queue for an asynchronous callback function, where each key has its own queue
  *
@@ -221,7 +221,7 @@ declare function isQueueInstance<Instance>(name: string, value: unknown): value
  * @param callback Callback function for queued items
  * @param options Queue options
  */
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
+export declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
 /**
  * Create a keyed queue for an asynchronous callback function, where each key has its own queue
  *
@@ -230,7 +230,7 @@ declare function keyedQueue<Callback extends (key: string, ...parameters: any[])
  * @param callback Callback function for queued items
  * @param options Queue options
  */
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
+export declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for an asynchronous callback function
  *
@@ -238,7 +238,7 @@ declare function keyedQueue<Callback extends (key: string, ...parameters: any[])
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
+export declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for a synchronous callback function
  *
@@ -246,9 +246,8 @@ declare function queue<Callback extends GenericAsyncCallback>(callback: Callback
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
-declare namespace queue {
+export declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
+export declare namespace queue {
   var keyed: typeof keyedQueue;
 }
-//#endregion
-export { KeyedQueue, Queue, QueueError, QueueOptions, Queued, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };
+//#endregion

package/dist/queue.mjs

@@ -1,6 +1,9 @@
 import { createAborter } from "./internal/abort.mjs";
 import { getBooleanOrDefault, getNumberOrDefault } from "./internal/defaults.mjs";
 //#region src/queue.ts
+const QUEUE_NAME_KEYED = "keyedQueue";
+const QUEUE_NAME_QUEUE = "queue";
+const QUEUE_PROPERTY = "$queue";
 /**
 * An error thrown by the Queue when an operation fails
 */
@@ -10,10 +13,159 @@ var QueueError = class extends Error {
 		this.name = QUEUE_ERROR_NAME;
 	}
 };
-function addToQueue(instance, state, parameters, signal) {
-	if (instance.full) throw new QueueError(QUEUE_MESSAGE_MAXIMUM);
+function KeyedQueue(callback, options) {
+	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+		callback,
+		options: createQueueOptions(options),
+		queues: /* @__PURE__ */ new Map()
+	} });
+}
+Object.defineProperties(KeyedQueue.prototype, {
+	[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
+	active: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
+		}
+	},
+	add: { value: addKeyedQueue },
+	autostart: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.autostart;
+		}
+	},
+	clear: { value: clearQueues },
+	concurrency: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.concurrency;
+		}
+	},
+	empty: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
+		}
+	},
+	full: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
+		}
+	},
+	get: { value: getQueue },
+	items: {
+		enumerable: true,
+		get() {
+			return getQueueItems(this[QUEUE_SYMBOL]);
+		}
+	},
+	keys: {
+		enumerable: true,
+		get() {
+			return [...this[QUEUE_SYMBOL].queues.keys()];
+		}
+	},
+	maximum: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.maximum;
+		}
+	},
+	pause: { value: pauseQueues },
+	paused: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
+		}
+	},
+	queues: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].queues.size;
+		}
+	},
+	remove: { value: removeQueue },
+	resume: { value: resumeQueues }
+});
+function Queue(callback, options, key) {
+	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+		callback,
+		key,
+		options,
+		handled: [],
+		id: 0,
+		items: [],
+		paused: !options.autostart,
+		runners: 0
+	} });
+}
+Object.defineProperties(Queue.prototype, {
+	[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
+	active: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].runners > 0;
+		}
+	},
+	add: { value: addToQueue },
+	autostart: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.autostart;
+		}
+	},
+	clear: { value: clearQueue },
+	concurrency: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.concurrency;
+		}
+	},
+	empty: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].items.length === 0;
+		}
+	},
+	full: {
+		enumerable: true,
+		get() {
+			const state = this[QUEUE_SYMBOL];
+			return state.options.maximum > 0 && state.items.length >= state.options.maximum;
+		}
+	},
+	maximum: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.maximum;
+		}
+	},
+	pause: { value: pauseQueue },
+	paused: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].paused;
+		}
+	},
+	remove: { value: removeQueued },
+	resume: { value: resumeQueue },
+	size: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].items.length;
+		}
+	}
+});
+function addKeyedQueue(key, parameters, signal) {
+	return getQueue.call(this, key, true).add(parameters, signal);
+}
+function addToQueue(parameters, signal) {
+	if (this.full) throw new QueueError(QUEUE_MESSAGE_MAXIMUM);
 	const abortSignal = signal instanceof AbortSignal ? signal : void 0;
 	if (abortSignal?.aborted ?? false) throw new Error(abortSignal?.reason);
+	const state = this[QUEUE_SYMBOL];
 	const id = identify(state);
 	let rejector;
 	let resolver;
@@ -37,8 +189,8 @@ function addToQueue(instance, state, parameters, signal) {
 		promise
 	};
 }
-function clearQueue(state) {
-	const items = state.items.splice(0);
+function clearQueue() {
+	const items = this[QUEUE_SYMBOL].items.splice(0);
 	const { length } = items;
 	for (let index = 0; index < length; index += 1) {
 		const { aborter, reject } = items[index];
@@ -46,63 +198,12 @@ function clearQueue(state) {
 		reject(new QueueError(QUEUE_MESSAGE_CLEAR));
 	}
 }
+function clearQueues(key) {
+	handleQueues(this, QUEUE_HANDLE_CLEAR, key);
+}
 function createQueue(callback, options, key) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
-	const state = {
-		callback,
-		key,
-		handled: [],
-		id: 0,
-		items: [],
-		options: createQueueOptions(options),
-		paused: !getBooleanOrDefault(options?.autostart, true),
-		runners: 0
-	};
-	const instance = {
-		add: (parameters, signal) => addToQueue(instance, state, parameters, signal),
-		clear: () => clearQueue(state),
-		pause: () => {
-			state.paused = true;
-		},
-		remove: (id) => removeQueued(state, id),
-		resume: () => resumeQueue(state)
-	};
-	Object.defineProperties(instance, {
-		[QUEUE_PROPERTY]: { value: QUEUE_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);
+	return new Queue(callback, createQueueOptions(options), key);
 }
 function createQueueOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
@@ -112,8 +213,9 @@ function createQueueOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function getQueue(state, key, add) {
+function getQueue(key, add) {
 	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
+	const state = this[QUEUE_SYMBOL];
 	let queue = state.queues.get(key);
 	if (queue == null && add === true) {
 		queue = createQueue(state.callback, state.options, key);
@@ -145,12 +247,12 @@ function handleQueuedResult(item, error, result) {
 	}
 	item.resolve(result);
 }
-function handleQueues(state, type, key) {
+function handleQueues(instance, type, key) {
 	if (typeof key === "string") {
-		getQueue(state, key)?.[type]();
+		getQueue.call(instance, key)?.[type]();
 		return;
 	}
-	const queues = state.queues.values();
+	const queues = instance[QUEUE_SYMBOL].queues.values();
 	for (const queue of queues) queue[type]();
 }
 function identify(state) {
@@ -176,78 +278,29 @@ function isQueue(value) {
 	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && value[QUEUE_PROPERTY] === name;
+	return typeof value === "object" && value != null && QUEUE_PROPERTY in value && value[QUEUE_PROPERTY] === name;
 }
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
-	const state = {
-		callback,
-		options: createQueueOptions(options),
-		queues: /* @__PURE__ */ new Map()
-	};
-	const instance = {
-		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
-		clear: (key) => handleQueues(state, QUEUE_HANDLE_CLEAR, key),
-		get: (key) => getQueue(state, key),
-		pause: (key) => handleQueues(state, QUEUE_HANDLE_PAUSE, key),
-		remove: (key, id) => removeQueue(state, key, id),
-		resume: (key) => handleQueues(state, QUEUE_HANDLE_RESUME, key)
-	};
-	Object.defineProperties(instance, {
-		[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
-		active: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_ACTIVE)
-		},
-		autostart: {
-			enumerable: true,
-			get: () => state.options.autostart
-		},
-		concurrency: {
-			enumerable: true,
-			get: () => state.options.concurrency
-		},
-		empty: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_EMPTY)
-		},
-		full: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_FULL)
-		},
-		items: {
-			enumerable: true,
-			get: () => getQueueItems(state)
-		},
-		keys: {
-			enumerable: true,
-			get: () => [...state.queues.keys()]
-		},
-		maximum: {
-			enumerable: true,
-			get: () => state.options.maximum
-		},
-		paused: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_PAUSED)
-		},
-		queues: {
-			enumerable: true,
-			get: () => state.queues.size
-		}
-	});
-	return Object.freeze(instance);
+	return new KeyedQueue(callback, createQueueOptions(options));
+}
+function pauseQueue() {
+	this[QUEUE_SYMBOL].paused = true;
+}
+function pauseQueues(key) {
+	handleQueues(this, QUEUE_HANDLE_PAUSE, key);
 }
 function queue(callback, options) {
 	return createQueue(callback, options);
 }
-function removeQueue(state, key, id) {
+function removeQueue(key, id) {
+	const state = this[QUEUE_SYMBOL];
 	if (key == null) {
-		handleQueues(state, QUEUE_HANDLE_CLEAR);
+		handleQueues(this, QUEUE_HANDLE_CLEAR);
 		state.queues.clear();
 		return;
 	}
-	const queue = getQueue(state, key);
+	const queue = getQueue.call(this, key);
 	if (queue == null) return;
 	if (typeof id === "number") {
 		queue.remove(id);
@@ -256,7 +309,8 @@ function removeQueue(state, key, id) {
 	queue.clear();
 	state.queues.delete(key);
 }
-function removeQueued(state, id) {
+function removeQueued(id) {
+	const state = this[QUEUE_SYMBOL];
 	const index = state.items.findIndex((item) => item.id === id);
 	if (index > -1) {
 		const { aborter, reject } = state.items.splice(index, 1)[0];
@@ -264,7 +318,8 @@ function removeQueued(state, id) {
 		reject(new QueueError(QUEUE_MESSAGE_REMOVE));
 	}
 }
-function resumeQueue(state) {
+function resumeQueue() {
+	const state = this[QUEUE_SYMBOL];
 	if (state.paused) {
 		const handled = state.handled.splice(0);
 		const { length } = handled;
@@ -274,6 +329,9 @@ function resumeQueue(state) {
 	const length = Math.min(state.options.concurrency, state.items.length);
 	for (let index = 0; index < length; index += 1) run(state);
 }
+function resumeQueues(key) {
+	handleQueues(this, QUEUE_HANDLE_RESUME, key);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -301,7 +359,6 @@ async function run(state) {
 	state.runners -= 1;
 }
 const QUEUE_ERROR_NAME = "QueueError";
-const QUEUE_PROPERTY = "$queue";
 const QUEUE_HANDLE_CLEAR = "clear";
 const QUEUE_HANDLE_PAUSE = "pause";
 const QUEUE_HANDLE_RESUME = "resume";
@@ -310,12 +367,11 @@ const QUEUE_MESSAGE_CLEAR = "Queue was cleared";
 const QUEUE_MESSAGE_KEY = "Key must be a non-empty string";
 const QUEUE_MESSAGE_MAXIMUM = "Queue has reached its maximum size";
 const QUEUE_MESSAGE_REMOVE = "Item removed from queue";
-const QUEUE_NAME_KEYED = "keyedQueue";
-const QUEUE_NAME_QUEUE = "queue";
 const QUEUE_STATUS_ACTIVE = "active";
 const QUEUE_STATUS_EMPTY = "empty";
 const QUEUE_STATUS_FULL = "full";
 const QUEUE_STATUS_PAUSED = "paused";
+const QUEUE_SYMBOL = Symbol(QUEUE_PROPERTY);
 queue.keyed = keyedQueue;
 Object.defineProperty(queue, "keyed", { value: keyedQueue });
 //#endregion