@oscarpalmer/atoms 0.202.0 → 0.204.0

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 { createAborter } from "../internal/aborter.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 { createAborter } from "./internal/aborter.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,122 @@ 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) {
+	this[QUEUE_SYMBOL] = {
+		callback,
+		options: createQueueOptions(options),
+		queues: /* @__PURE__ */ new Map()
+	};
+}
+KeyedQueue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_KEYED;
+KeyedQueue.prototype.add = addKeyedQueue;
+KeyedQueue.prototype.clear = clearQueues;
+KeyedQueue.prototype.get = getQueue;
+KeyedQueue.prototype.pause = pauseQueues;
+KeyedQueue.prototype.remove = removeQueue;
+KeyedQueue.prototype.resume = resumeQueues;
+Object.defineProperties(KeyedQueue.prototype, {
+	active: {
+		enumerable: true,
+		get: getActiveQueues
+	},
+	autostart: {
+		enumerable: true,
+		get: getQueueAutostart
+	},
+	concurrency: {
+		enumerable: true,
+		get: getQueueConcurrency
+	},
+	empty: {
+		enumerable: true,
+		get: getEmptyQueues
+	},
+	full: {
+		enumerable: true,
+		get: getFullQueues
+	},
+	items: {
+		enumerable: true,
+		get: getKeyedQueueItems
+	},
+	keys: {
+		enumerable: true,
+		get: getQueueKeys
+	},
+	maximum: {
+		enumerable: true,
+		get: getQueueMaximum
+	},
+	paused: {
+		enumerable: true,
+		get: getPausedQueues
+	},
+	queues: {
+		enumerable: true,
+		get: getKeyedQueueSize
+	}
+});
+function Queue(callback, options, key) {
+	this[QUEUE_SYMBOL] = {
+		callback,
+		key,
+		options,
+		handled: [],
+		id: 0,
+		items: [],
+		paused: !options.autostart,
+		runners: 0
+	};
+}
+Queue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_QUEUE;
+Queue.prototype.add = addToQueue;
+Queue.prototype.clear = clearQueue;
+Queue.prototype.pause = pauseQueue;
+Queue.prototype.remove = removeQueued;
+Queue.prototype.resume = resumeQueue;
+Object.defineProperties(Queue.prototype, {
+	active: {
+		enumerable: true,
+		get: getQueueActive
+	},
+	autostart: {
+		enumerable: true,
+		get: getQueueAutostart
+	},
+	concurrency: {
+		enumerable: true,
+		get: getQueueConcurrency
+	},
+	empty: {
+		enumerable: true,
+		get: getQueueEmpty
+	},
+	full: {
+		enumerable: true,
+		get: getQueueFull
+	},
+	maximum: {
+		enumerable: true,
+		get: getQueueMaximum
+	},
+	paused: {
+		enumerable: true,
+		get: getQueuePaused
+	},
+	size: {
+		enumerable: true,
+		get: getQueueSize
+	}
+});
+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 +152,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 +161,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 +176,31 @@ function createQueueOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function getQueue(state, key, add) {
+function getActiveQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
+}
+function getEmptyQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
+}
+function getFullQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
+}
+function getPausedQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
+}
+function getKeyedQueueItems() {
+	const state = this[QUEUE_SYMBOL];
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
+function getKeyedQueueSize() {
+	return this[QUEUE_SYMBOL].queues.size;
+}
+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);
@@ -121,11 +208,33 @@ function getQueue(state, key, add) {
 	}
 	return queue;
 }
-function getQueueItems(state) {
-	const size = {};
-	const queues = state.queues.entries();
-	for (const [key, queue] of queues) size[key] = queue.size;
-	return size;
+function getQueueActive() {
+	return this[QUEUE_SYMBOL].runners > 0;
+}
+function getQueueAutostart() {
+	return this[QUEUE_SYMBOL].options.autostart === true;
+}
+function getQueueConcurrency() {
+	return this[QUEUE_SYMBOL].options.concurrency;
+}
+function getQueueEmpty() {
+	return this[QUEUE_SYMBOL].items.length === 0;
+}
+function getQueueFull() {
+	const state = this[QUEUE_SYMBOL];
+	return state.options.maximum > 0 && state.items.length >= state.options.maximum;
+}
+function getQueueKeys() {
+	return [...this[QUEUE_SYMBOL].queues.keys()];
+}
+function getQueueMaximum() {
+	return this[QUEUE_SYMBOL].options.maximum;
+}
+function getQueuePaused() {
+	return this[QUEUE_SYMBOL].paused === true;
+}
+function getQueueSize() {
+	return this[QUEUE_SYMBOL].items.length;
 }
 function getStatus(state, status) {
 	const queues = state.queues.entries();
@@ -145,12 +254,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 +285,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 +316,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 +325,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 +336,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 +366,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,13 +374,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
 export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/random.d.mts

@@ -5,7 +5,7 @@ import { getRandomFloatingNumber, getRandomInteger } from "./internal/random.mjs
  *
  * @returns Random boolean
  */
-declare function getRandomBoolean(): boolean;
+export declare function getRandomBoolean(): boolean;
 /**
  * Get a random string of characters with a specified length
  *
@@ -13,27 +13,27 @@ declare function getRandomBoolean(): boolean;
  * @param selection String of characters to select from _(defaults to lowercase English alphabet)_
  * @returns Random string of characters
  */
-declare function getRandomCharacters(length: number, selection?: string): string;
+export declare function getRandomCharacters(length: number, selection?: string): string;
 /**
  * Get a random hexadecimal color
  *
  * @param prefix Prefix the color with `#`? _(defaults to `false`)_
  * @returns Random hexadecimal color string in the format `(#)RRGGBB`
  */
-declare function getRandomColor(prefix?: boolean): string;
+export declare function getRandomColor(prefix?: boolean): string;
 /**
  * Get a random hexadecimal character
  *
  * @returns Random hexadecimal character from `0-9` and `A-F`
  */
-declare function getRandomHex(): string;
+export declare function getRandomHex(): string;
 /**
  * Get a random item from an array
  *
  * @param array Array to get a random item from
  * @returns Random item from the array, or `undefined` if unable to retrieve one
  */
-declare function getRandomItem<Value>(array: Value[]): Value | undefined;
+export declare function getRandomItem<Value>(array: Value[]): Value | undefined;
 /**
  * Get an amount of random items from an array
  *
@@ -41,13 +41,13 @@ declare function getRandomItem<Value>(array: Value[]): Value | undefined;
  * @param amount Amount of items to return
  * @returns Array of random items
  */
-declare function getRandomItems<Value>(array: Value[], amount: number): Value[];
+export declare function getRandomItems<Value>(array: Value[], amount: number): Value[];
 /**
  * Get a shuffled array
  *
  * @param array Array to get random items from
  * @returns Shuffled version of the original array
  */
-declare function getRandomItems<Value>(array: Value[]): Value[];
+export declare function getRandomItems<Value>(array: Value[]): Value[];
 //#endregion
-export { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems };
+export { getRandomFloatingNumber as getRandomFloat, getRandomInteger };