@sv443-network/userutils 9.4.3 → 10.0.0

package/dist/lib/DataStore.d.ts

@@ -1,164 +0,0 @@
-/**
- * @module lib/DataStore  
- * This module contains the DataStore class, which is a general purpose, sync and async persistent JSON database - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#datastore)  
- */
-import type { Prettify } from "./types.js";
-/** Function that takes the data in the old format and returns the data in the new format. Also supports an asynchronous migration. */
-type MigrationFunc = (oldData: any) => any | Promise<any>;
-/** Dictionary of format version numbers and the function that migrates to them from the previous whole integer */
-export type DataMigrationsDict = Record<number, MigrationFunc>;
-/** Options for the DataStore instance */
-export type DataStoreOptions<TData> = Prettify<{
-    /**
-     * A unique internal ID for this data store.  
-     * To avoid conflicts with other scripts, it is recommended to use a prefix that is unique to your script.  
-     * If you want to change the ID, you should make use of the {@linkcode DataStore.migrateId()} method.  
-     */
-    id: string;
-    /**
-     * The default data object to use if no data is saved in persistent storage yet.  
-     * Until the data is loaded from persistent storage with {@linkcode DataStore.loadData()}, this will be the data returned by {@linkcode DataStore.getData()}.  
-     *  
-     * - ⚠️ This has to be an object that can be serialized to JSON using `JSON.stringify()`, so no functions or circular references are allowed, they will cause unexpected behavior.  
-     */
-    defaultData: TData;
-    /**
-     * An incremental, whole integer version number of the current format of data.  
-     * If the format of the data is changed in any way, this number should be incremented, in which case all necessary functions of the migrations dictionary will be run consecutively.  
-     *  
-     * - ⚠️ Never decrement this number and optimally don't skip any numbers either!  
-     */
-    formatVersion: number;
-    /**
-     * A dictionary of functions that can be used to migrate data from older versions to newer ones.  
-     * The keys of the dictionary should be the format version that the functions can migrate to, from the previous whole integer value.  
-     * The values should be functions that take the data in the old format and return the data in the new format.  
-     * The functions will be run in order from the oldest to the newest version.  
-     * If the current format version is not in the dictionary, no migrations will be run.  
-     */
-    migrations?: DataMigrationsDict;
-    /**
-     * If an ID or multiple IDs are passed here, the data will be migrated from the old ID(s) to the current ID.  
-     * This will happen once per page load, when {@linkcode DataStore.loadData()} is called.  
-     * All future calls to {@linkcode DataStore.loadData()} in the session will not check for the old ID(s) anymore.  
-     * To migrate IDs manually, use the method {@linkcode DataStore.migrateId()} instead.  
-     */
-    migrateIds?: string | string[];
-    /**
-     * Where the data should be saved (`"GM"` by default).  
-     * The protected methods {@linkcode DataStore.getValue()}, {@linkcode DataStore.setValue()}  and {@linkcode DataStore.deleteValue()} are used to interact with the storage.  
-     * `"GM"` storage, `"localStorage"` and `"sessionStorage"` are supported out of the box, but in an extended class you can overwrite those methods to implement any other storage method.  
-     */
-    storageMethod?: "GM" | "localStorage" | "sessionStorage";
-} & ({
-    /**
-     * Function to use to encode the data prior to saving it in persistent storage.  
-     * If this is specified, make sure to declare {@linkcode decodeData()} as well.  
-     *  
-     * You can make use of UserUtils' [`compress()`](https://github.com/Sv443-Network/UserUtils?tab=readme-ov-file#compress) function here to make the data use up less space at the cost of a little bit of performance.  
-     * @param data The input data as a serialized object (JSON string)  
-     */
-    encodeData: (data: string) => string | Promise<string>;
-    /**
-     * Function to use to decode the data after reading it from persistent storage.  
-     * If this is specified, make sure to declare {@linkcode encodeData()} as well.  
-     *  
-     * You can make use of UserUtils' [`decompress()`](https://github.com/Sv443-Network/UserUtils?tab=readme-ov-file#decompress) function here to make the data use up less space at the cost of a little bit of performance.  
-     * @returns The resulting data as a valid serialized object (JSON string)  
-     */
-    decodeData: (data: string) => string | Promise<string>;
-} | {
-    encodeData?: never;
-    decodeData?: never;
-})>;
-/**
- * Manages a hybrid synchronous & asynchronous persistent JSON database that is cached in memory and persistently saved across sessions using [GM storage](https://wiki.greasespot.net/GM.setValue) (default), [localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) or [sessionStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage).  
- * Supports migrating data from older format versions to newer ones and populating the cache with default data if no persistent data is found.  
- * Can be overridden to implement any other storage method.  
- *  
- * All methods are `protected` or `public`, so you can easily extend this class and overwrite them to use a different storage method or to add other functionality.  
- * Remember that you can use `super.methodName()` in the subclass to call the original method if needed.  
- *  
- * - ⚠️ The data is stored as a JSON string, so only data compatible with [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify) can be used. Circular structures and complex objects (containing functions, symbols, etc.) will either throw an error on load and save or cause otherwise unexpected behavior. Properties with a value of `undefined` will be removed from the data prior to saving it, so use `null` instead.  
- * - ⚠️ If the storageMethod is left as the default of `"GM"`, the directives `@grant GM.getValue` and `@grant GM.setValue` are required. If you then also use the method {@linkcode DataStore.deleteData()}, the extra directive `@grant GM.deleteValue` is needed too.  
- * - ⚠️ Make sure to call {@linkcode loadData()} at least once after creating an instance, or the returned data will be the same as `options.defaultData`  
- *  
- * @template TData The type of the data that is saved in persistent storage for the currently set format version (will be automatically inferred from `defaultData` if not provided)  
- */
-export declare class DataStore<TData extends object = object> {
-    readonly id: string;
-    readonly formatVersion: number;
-    readonly defaultData: TData;
-    readonly encodeData: DataStoreOptions<TData>["encodeData"];
-    readonly decodeData: DataStoreOptions<TData>["decodeData"];
-    readonly storageMethod: Required<DataStoreOptions<TData>>["storageMethod"];
-    private cachedData;
-    private migrations?;
-    private migrateIds;
-    /**
-     * Creates an instance of DataStore to manage a sync & async database that is cached in memory and persistently saved across sessions.  
-     * Supports migrating data from older versions to newer ones and populating the cache with default data if no persistent data is found.  
-     *  
-     * - ⚠️ Requires the directives `@grant GM.getValue` and `@grant GM.setValue` if the storageMethod is left as the default of `"GM"`  
-     * - ⚠️ Make sure to call {@linkcode loadData()} at least once after creating an instance, or the returned data will be the same as `options.defaultData`  
-     *  
-     * @template TData The type of the data that is saved in persistent storage for the currently set format version (will be automatically inferred from `defaultData` if not provided) - **This has to be a JSON-compatible object!** (no undefined, circular references, etc.)  
-     * @param options The options for this DataStore instance  
-     */
-    constructor(options: DataStoreOptions<TData>);
-    /**
-     * Loads the data saved in persistent storage into the in-memory cache and also returns it.  
-     * Automatically populates persistent storage with default data if it doesn't contain any data yet.  
-     * Also runs all necessary migration functions if the data format has changed since the last time the data was saved.  
-     */
-    loadData(): Promise<TData>;
-    /**
-     * Returns a copy of the data from the in-memory cache.  
-     * Use {@linkcode loadData()} to get fresh data from persistent storage (usually not necessary since the cache should always exactly reflect persistent storage).  
-     * @param deepCopy Whether to return a deep copy of the data (default: `false`) - only necessary if your data object is nested and may have a bigger performance impact if enabled  
-     */
-    getData(deepCopy?: boolean): TData;
-    /** Saves the data synchronously to the in-memory cache and asynchronously to the persistent storage */
-    setData(data: TData): Promise<void>;
-    /** Saves the default data passed in the constructor synchronously to the in-memory cache and asynchronously to persistent storage */
-    saveDefaultData(): Promise<void>;
-    /**
-     * Call this method to clear all persistently stored data associated with this DataStore instance.  
-     * The in-memory cache will be left untouched, so you may still access the data with {@linkcode getData()}  
-     * Calling {@linkcode loadData()} or {@linkcode setData()} after this method was called will recreate persistent storage with the cached or default data.  
-     *  
-     * - ⚠️ This requires the additional directive `@grant GM.deleteValue` if the storageMethod is left as the default of `"GM"`  
-     */
-    deleteData(): Promise<void>;
-    /** Returns whether encoding and decoding are enabled for this DataStore instance */
-    encodingEnabled(): this is Required<Pick<DataStoreOptions<TData>, "encodeData" | "decodeData">>;
-    /**
-     * Runs all necessary migration functions consecutively and saves the result to the in-memory cache and persistent storage and also returns it.  
-     * This method is automatically called by {@linkcode loadData()} if the data format has changed since the last time the data was saved.  
-     * Though calling this method manually is not necessary, it can be useful if you want to run migrations for special occasions like a user importing potentially outdated data that has been previously exported.  
-     *  
-     * If one of the migrations fails, the data will be reset to the default value if `resetOnError` is set to `true` (default). Otherwise, an error will be thrown and no data will be saved.  
-     */
-    runMigrations(oldData: unknown, oldFmtVer: number, resetOnError?: boolean): Promise<TData>;
-    /**
-     * Tries to migrate the currently saved persistent data from one or more old IDs to the ID set in the constructor.  
-     * If no data exist for the old ID(s), nothing will be done, but some time may still pass trying to fetch the non-existent data.  
-     */
-    migrateId(oldIds: string | string[]): Promise<void>;
-    /** Serializes the data using the optional this.encodeData() and returns it as a string */
-    protected serializeData(data: TData, useEncoding?: boolean): Promise<string>;
-    /** Deserializes the data using the optional this.decodeData() and returns it as a JSON object */
-    protected deserializeData(data: string, useEncoding?: boolean): Promise<TData>;
-    /** Copies a JSON-compatible object and loses all its internal references in the process */
-    protected deepCopy<T>(obj: T): T;
-    /** Gets a value from persistent storage - can be overwritten in a subclass if you want to use something other than the default storage methods */
-    protected getValue<TValue extends GM.Value = string>(name: string, defaultValue: TValue): Promise<string | TValue>;
-    /**
-     * Sets a value in persistent storage - can be overwritten in a subclass if you want to use something other than the default storage methods.  
-     * The default storage engines will stringify all passed values like numbers or booleans, so be aware of that.  
-     */
-    protected setValue(name: string, value: GM.Value): Promise<void>;
-    /** Deletes a value from persistent storage - can be overwritten in a subclass if you want to use something other than the default storage methods */
-    protected deleteValue(name: string): Promise<void>;
-}
-export {};

package/dist/lib/DataStoreSerializer.d.ts

@@ -1,115 +0,0 @@
-/**
- * @module lib/DataStoreSerializer  
- * This module contains the DataStoreSerializer class, which allows you to import and export serialized DataStore data - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#datastoreserializer)  
- */
-import type { DataStore } from "./DataStore.js";
-export type DataStoreSerializerOptions = {
-    /** Whether to add a checksum to the exported data. Defaults to `true` */
-    addChecksum?: boolean;
-    /** Whether to ensure the integrity of the data when importing it by throwing an error (doesn't throw when the checksum property doesn't exist). Defaults to `true` */
-    ensureIntegrity?: boolean;
-};
-/** Serialized data of a DataStore instance */
-export type SerializedDataStore = {
-    /** The ID of the DataStore instance */
-    id: string;
-    /** The serialized data */
-    data: string;
-    /** The format version of the data */
-    formatVersion: number;
-    /** Whether the data is encoded */
-    encoded: boolean;
-    /** The checksum of the data - key is not present when `addChecksum` is `false` */
-    checksum?: string;
-};
-/** Result of {@linkcode DataStoreSerializer.loadStoresData()} */
-export type LoadStoresDataResult = {
-    /** The ID of the DataStore instance */
-    id: string;
-    /** The in-memory data object */
-    data: object;
-};
-/** A filter for selecting data stores */
-export type StoreFilter = string[] | ((id: string) => boolean);
-/**
- * Allows for easy serialization and deserialization of multiple DataStore instances.  
- *  
- * All methods are at least `protected`, so you can easily extend this class and overwrite them to use a different storage method or to add additional functionality.  
- * Remember that you can call `super.methodName()` in the subclass to access the original method.  
- *  
- * - ⚠️ Needs to run in a secure context (HTTPS) due to the use of the SubtleCrypto API if checksumming is enabled.  
- */
-export declare class DataStoreSerializer {
-    protected stores: DataStore[];
-    protected options: Required<DataStoreSerializerOptions>;
-    constructor(stores: DataStore[], options?: DataStoreSerializerOptions);
-    /** Calculates the checksum of a string */
-    protected calcChecksum(input: string): Promise<string>;
-    /**
-     * Serializes only a subset of the data stores into a string.  
-     * @param stores An array of store IDs or functions that take a store ID and return a boolean  
-     * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
-     * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
-     */
-    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: true): Promise<string>;
-    /**
-     * Serializes only a subset of the data stores into a string.  
-     * @param stores An array of store IDs or functions that take a store ID and return a boolean  
-     * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
-     * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
-     */
-    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore[]>;
-    /**
-     * Serializes only a subset of the data stores into a string.  
-     * @param stores An array of store IDs or functions that take a store ID and return a boolean  
-     * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
-     * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
-     */
-    serializePartial(stores: StoreFilter, useEncoding?: boolean, stringified?: boolean): Promise<string | SerializedDataStore[]>;
-    /**
-     * Serializes the data stores into a string.  
-     * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
-     * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
-     */
-    serialize(useEncoding?: boolean, stringified?: true): Promise<string>;
-    /**
-     * Serializes the data stores into a string.  
-     * @param useEncoding Whether to encode the data using each DataStore's `encodeData()` method  
-     * @param stringified Whether to return the result as a string or as an array of `SerializedDataStore` objects  
-     */
-    serialize(useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore[]>;
-    /**
-     * Deserializes the data exported via {@linkcode serialize()} and imports only a subset into the DataStore instances.  
-     * Also triggers the migration process if the data format has changed.  
-     */
-    deserializePartial(stores: StoreFilter, data: string | SerializedDataStore[]): Promise<void>;
-    /**
-     * Deserializes the data exported via {@linkcode serialize()} and imports the data into all matching DataStore instances.  
-     * Also triggers the migration process if the data format has changed.  
-     */
-    deserialize(data: string | SerializedDataStore[]): Promise<void>;
-    /**
-     * Loads the persistent data of the DataStore instances into the in-memory cache.  
-     * Also triggers the migration process if the data format has changed.  
-     * @param stores An array of store IDs or a function that takes the store IDs and returns a boolean - if omitted, all stores will be loaded  
-     * @returns Returns a PromiseSettledResult array with the results of each DataStore instance in the format `{ id: string, data: object }`  
-     */
-    loadStoresData(stores?: StoreFilter): Promise<PromiseSettledResult<LoadStoresDataResult>[]>;
-    /**
-     * Resets the persistent and in-memory data of the DataStore instances to their default values.  
-     * @param stores An array of store IDs or a function that takes the store IDs and returns a boolean - if omitted, all stores will be affected  
-     */
-    resetStoresData(stores?: StoreFilter): Promise<PromiseSettledResult<void>[]>;
-    /**
-     * Deletes the persistent data of the DataStore instances.  
-     * Leaves the in-memory data untouched.  
-     * @param stores An array of store IDs or a function that takes the store IDs and returns a boolean - if omitted, all stores will be affected  
-     */
-    deleteStoresData(stores?: StoreFilter): Promise<PromiseSettledResult<void>[]>;
-    /** Checks if a given value is an array of SerializedDataStore objects */
-    static isSerializedDataStoreObjArray(obj: unknown): obj is SerializedDataStore[];
-    /** Checks if a given value is a SerializedDataStore object */
-    static isSerializedDataStoreObj(obj: unknown): obj is SerializedDataStore;
-    /** Returns the DataStore instances whose IDs match the provided array or function */
-    protected getStoresFiltered(stores?: StoreFilter): DataStore[];
-}

package/dist/lib/Debouncer.d.ts

@@ -1,86 +0,0 @@
-/**
- * @module lib/Debouncer  
- * This module contains the Debouncer class and debounce function that allow you to reduce the amount of calls in rapidly firing event listeners and such - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#debouncer)  
- */
-import { NanoEmitter } from "./NanoEmitter.js";
-/**
- * The type of edge to use for the debouncer - [see the docs for a diagram and explanation.](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#debouncer)  
- * - `immediate` - (default & recommended) - calls the listeners at the very first call ("rising" edge) and queues the latest call until the timeout expires  
- *   - Pros:  
- *     - First call is let through immediately  
- *   - Cons:  
- *     - After all calls stop, the JS engine's event loop will continue to run until the last timeout expires (doesn't really matter on the web, but could cause a process exit delay in Node.js)  
- * - `idle` - queues all calls until there are no more calls in the given timeout duration ("falling" edge), and only then executes the very last call  
- *   - Pros:  
- *     - Makes sure there are zero calls in the given `timeoutDuration` before executing the last call  
- *   - Cons:  
- *     - Calls are always delayed by at least `1 * timeoutDuration`  
- *     - Calls could get stuck in the queue indefinitely if there is no downtime between calls that is greater than the `timeoutDuration`  
- */
-export type DebouncerType = "immediate" | "idle";
-type AnyFunc = (...args: any) => any;
-/** The debounced function type that is returned by the {@linkcode debounce} function */
-export type DebouncedFunction<TFunc extends AnyFunc> = ((...args: Parameters<TFunc>) => ReturnType<TFunc>) & {
-    debouncer: Debouncer<TFunc>;
-};
-/** Event map for the {@linkcode Debouncer} */
-export type DebouncerEventMap<TFunc extends AnyFunc> = {
-    /** Emitted when the debouncer calls all registered listeners, as a pub-sub alternative */
-    call: TFunc;
-    /** Emitted when the timeout or edge type is changed after the instance was created */
-    change: (timeout: number, type: DebouncerType) => void;
-};
-/**
- * A debouncer that calls all listeners after a specified timeout, discarding all calls in-between.  
- * It is very useful for event listeners that fire quickly, like `input` or `mousemove`, to prevent the listeners from being called too often and hogging resources.  
- * The exact behavior can be customized with the `type` parameter.  
- *  
- * The instance inherits from {@linkcode NanoEmitter} and emits the following events:  
- * - `call` - emitted when the debouncer calls all listeners - use this as a pub-sub alternative to the default callback-style listeners  
- * - `change` - emitted when the timeout or edge type is changed after the instance was created  
- */
-export declare class Debouncer<TFunc extends AnyFunc> extends NanoEmitter<DebouncerEventMap<TFunc>> {
-    protected timeout: number;
-    protected type: DebouncerType;
-    /** All registered listener functions and the time they were attached */
-    protected listeners: TFunc[];
-    /** The currently active timeout */
-    protected activeTimeout: ReturnType<typeof setTimeout> | undefined;
-    /** The latest queued call */
-    protected queuedCall: (() => void) | undefined;
-    /**
-     * Creates a new debouncer with the specified timeout and edge type.  
-     * @param timeout Timeout in milliseconds between letting through calls - defaults to 200  
-     * @param type The edge type to use for the debouncer - see {@linkcode DebouncerType} for details or [the documentation for an explanation and diagram](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#debouncer) - defaults to "immediate"  
-     */
-    constructor(timeout?: number, type?: DebouncerType);
-    /** Adds a listener function that will be called on timeout */
-    addListener(fn: TFunc): void;
-    /** Removes the listener with the specified function reference */
-    removeListener(fn: TFunc): void;
-    /** Removes all listeners */
-    removeAllListeners(): void;
-    /** Returns all registered listeners */
-    getListeners(): TFunc[];
-    /** Sets the timeout for the debouncer */
-    setTimeout(timeout: number): void;
-    /** Returns the current timeout */
-    getTimeout(): number;
-    /** Whether the timeout is currently active, meaning any latest call to the {@linkcode call()} method will be queued */
-    isTimeoutActive(): boolean;
-    /** Sets the edge type for the debouncer */
-    setType(type: DebouncerType): void;
-    /** Returns the current edge type */
-    getType(): DebouncerType;
-    /** Use this to call the debouncer with the specified arguments that will be passed to all listener functions registered with {@linkcode addListener()} */
-    call(...args: Parameters<TFunc>): void;
-}
-/**
- * Creates a {@linkcode Debouncer} instance with the specified timeout and edge type and attaches the passed function as a listener.  
- * The returned function can be called with any arguments and will execute the `call()` method of the debouncer.  
- * The debouncer instance is accessible via the `debouncer` property of the returned function.  
- *  
- * Refer to the {@linkcode Debouncer} class definition or the [Debouncer documentation](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#debouncer) for more information.  
- */
-export declare function debounce<TFunc extends (...args: any[]) => any>(fn: TFunc, timeout?: number, type?: DebouncerType): DebouncedFunction<TFunc>;
-export {};

package/dist/lib/NanoEmitter.d.ts

@@ -1,71 +0,0 @@
-/**
- * @module lib/NanoEmitter  
- * This module contains the NanoEmitter class, which is a tiny event emitter powered by [nanoevents](https://www.npmjs.com/package/nanoevents) - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#nanoemitter)  
- */
-import { type DefaultEvents, type Emitter, type EventsMap, type Unsubscribe } from "nanoevents";
-export interface NanoEmitterOptions {
-    /** If set to true, allows emitting events through the public method emit() */
-    publicEmit: boolean;
-}
-/**
- * Class that can be extended or instantiated by itself to create a lightweight event emitter with helper methods and a strongly typed event map.  
- * If extended from, you can use `this.events.emit()` to emit events, even if the `emit()` method doesn't work because `publicEmit` is not set to true in the constructor.  
- */
-export declare class NanoEmitter<TEvtMap extends EventsMap = DefaultEvents> {
-    protected readonly events: Emitter<TEvtMap>;
-    protected eventUnsubscribes: Unsubscribe[];
-    protected emitterOptions: NanoEmitterOptions;
-    /** Creates a new instance of NanoEmitter - a lightweight event emitter with helper methods and a strongly typed event map */
-    constructor(options?: Partial<NanoEmitterOptions>);
-    /**
-     * Subscribes to an event and calls the callback when it's emitted.  
-     * @param event The event to subscribe to. Use `as "_"` in case your event names aren't thoroughly typed (like when using a template literal, e.g. \`event-${val}\` as "_")  
-     * @returns Returns a function that can be called to unsubscribe the event listener  
-     * @example ```ts  
-     * const emitter = new NanoEmitter<{  
-     *   foo: (bar: string) => void;  
-     * }>({  
-     *   publicEmit: true,  
-     * });  
-     *  
-     * let i = 0;  
-     * const unsub = emitter.on("foo", (bar) => {  
-     *   // unsubscribe after 10 events:  
-     *   if(++i === 10) unsub();  
-     *   console.log(bar);  
-     * });  
-     *  
-     * emitter.emit("foo", "bar");  
-     * ```  
-     */
-    on<TKey extends keyof TEvtMap>(event: TKey | "_", cb: TEvtMap[TKey]): () => void;
-    /**
-     * Subscribes to an event and calls the callback or resolves the Promise only once when it's emitted.  
-     * @param event The event to subscribe to. Use `as "_"` in case your event names aren't thoroughly typed (like when using a template literal, e.g. \`event-${val}\` as "_")  
-     * @param cb The callback to call when the event is emitted - if provided or not, the returned Promise will resolve with the event arguments  
-     * @returns Returns a Promise that resolves with the event arguments when the event is emitted  
-     * @example ```ts  
-     * const emitter = new NanoEmitter<{  
-     *   foo: (bar: string) => void;  
-     * }>();  
-     *  
-     * // Promise syntax:  
-     * const [bar] = await emitter.once("foo");  
-     * console.log(bar);  
-     *  
-     * // Callback syntax:  
-     * emitter.once("foo", (bar) => console.log(bar));  
-     * ```  
-     */
-    once<TKey extends keyof TEvtMap>(event: TKey | "_", cb?: TEvtMap[TKey]): Promise<Parameters<TEvtMap[TKey]>>;
-    /**
-     * Emits an event on this instance.  
-     * ⚠️ Needs `publicEmit` to be set to true in the NanoEmitter constructor or super() call!  
-     * @param event The event to emit  
-     * @param args The arguments to pass to the event listeners  
-     * @returns Returns true if `publicEmit` is true and the event was emitted successfully  
-     */
-    emit<TKey extends keyof TEvtMap>(event: TKey, ...args: Parameters<TEvtMap[TKey]>): boolean;
-    /** Unsubscribes all event listeners from this instance */
-    unsubscribeAll(): void;
-}

package/dist/lib/array.d.ts

@@ -1,17 +0,0 @@
-/**
- * @module lib/array  
- * This module contains various functions for working with arrays - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#arrays)  
- */
-/** Describes an array with at least one item */
-export type NonEmptyArray<TArray = unknown> = [TArray, ...TArray[]];
-/** Returns a random item from the passed array */
-export declare function randomItem<TItem = unknown>(array: TItem[]): TItem | undefined;
-/**
- * Returns a tuple of a random item and its index from the passed array  
- * Returns `[undefined, undefined]` if the passed array is empty  
- */
-export declare function randomItemIndex<TItem = unknown>(array: TItem[]): [item?: TItem, index?: number];
-/** Returns a random item from the passed array and mutates the array to remove the item */
-export declare function takeRandomItem<TItem = unknown>(arr: TItem[]): TItem | undefined;
-/** Returns a copy of the array with its items in a random order */
-export declare function randomizeArray<TItem = unknown>(array: TItem[]): TItem[];

package/dist/lib/colors.d.ts

@@ -1,25 +0,0 @@
-/**
- * @module lib/colors  
- * This module contains various functions for working with colors - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#colors)  
- */
-/**
- * Converts a hex color string in the format `#RRGGBB`, `#RRGGBBAA` (or even `RRGGBB` and `RGB`) to a tuple.  
- * @returns Returns a tuple array where R, G and B are an integer from 0-255 and alpha is a float from 0 to 1, or undefined if no alpha channel exists.  
- */
-export declare function hexToRgb(hex: string): [red: number, green: number, blue: number, alpha?: number];
-/** Converts RGB or RGBA number values to a hex color string in the format `#RRGGBB` or `#RRGGBBAA` */
-export declare function rgbToHex(red: number, green: number, blue: number, alpha?: number, withHash?: boolean, upperCase?: boolean): string;
-/**
- * Lightens a CSS color value (in #HEX, rgb() or rgba() format) by a given percentage.  
- * Will not exceed the maximum range (00-FF or 0-255).  
- * @returns Returns the new color value in the same format as the input  
- * @throws Throws if the color format is invalid or not supported  
- */
-export declare function lightenColor(color: string, percent: number, upperCase?: boolean): string;
-/**
- * Darkens a CSS color value (in #HEX, rgb() or rgba() format) by a given percentage.  
- * Will not exceed the maximum range (00-FF or 0-255).  
- * @returns Returns the new color value in the same format as the input  
- * @throws Throws if the color format is invalid or not supported  
- */
-export declare function darkenColor(color: string, percent: number, upperCase?: boolean): string;

package/dist/lib/crypto.d.ts

@@ -1,29 +0,0 @@
-/**
- * @module lib/crypto  
- * This module contains various cryptographic functions using the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API) - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#table-of-contents)  
- */
-/** Compresses a string or an ArrayBuffer using the provided {@linkcode compressionFormat} and returns it as a base64 string */
-export declare function compress(input: string | ArrayBuffer, compressionFormat: CompressionFormat, outputType?: "string"): Promise<string>;
-/** Compresses a string or an ArrayBuffer using the provided {@linkcode compressionFormat} and returns it as an ArrayBuffer */
-export declare function compress(input: string | ArrayBuffer, compressionFormat: CompressionFormat, outputType: "arrayBuffer"): Promise<ArrayBuffer>;
-/** Decompresses a previously compressed base64 string or ArrayBuffer, with the format passed by {@linkcode compressionFormat}, converted to a string */
-export declare function decompress(input: string | ArrayBuffer, compressionFormat: CompressionFormat, outputType?: "string"): Promise<string>;
-/** Decompresses a previously compressed base64 string or ArrayBuffer, with the format passed by {@linkcode compressionFormat}, converted to an ArrayBuffer */
-export declare function decompress(input: string | ArrayBuffer, compressionFormat: CompressionFormat, outputType: "arrayBuffer"): Promise<ArrayBuffer>;
-/**
- * Creates a hash / checksum of the given {@linkcode input} string or ArrayBuffer using the specified {@linkcode algorithm} ("SHA-256" by default).  
- *  
- * - ⚠️ Uses the SubtleCrypto API so it needs to run in a secure context (HTTPS).  
- * - ⚠️ If you use this for cryptography, make sure to use a secure algorithm (under no circumstances use SHA-1) and to [salt](https://en.wikipedia.org/wiki/Salt_(cryptography)) your input data.  
- */
-export declare function computeHash(input: string | ArrayBuffer, algorithm?: string): Promise<string>;
-/**
- * Generates a random ID with the specified length and radix (16 characters and hexadecimal by default)  
- *  
- * - ⚠️ Not suitable for generating anything related to cryptography! Use [SubtleCrypto's `generateKey()`](https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey) for that instead.  
- * @param length The length of the ID to generate (defaults to 16)  
- * @param radix The [radix](https://en.wikipedia.org/wiki/Radix) of each digit (defaults to 16 which is hexadecimal. Use 2 for binary, 10 for decimal, 36 for alphanumeric, etc.)  
- * @param enhancedEntropy If set to true, uses [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) for better cryptographic randomness (this also makes it take longer to generate)  
- * @param randomCase If set to false, the generated ID will be lowercase only - also makes use of the `enhancedEntropy` parameter unless the output doesn't contain letters  
- */
-export declare function randomId(length?: number, radix?: number, enhancedEntropy?: boolean, randomCase?: boolean): string;

package/dist/lib/errors.d.ts

@@ -1,21 +0,0 @@
-/**
- * @module lib/errors  
- * Contains custom error classes  
- */
-/** Base class for all UserUtils errors - adds a `date` prop set to the error throw time */
-export declare class UUError extends Error {
-    readonly date: Date;
-    constructor(message: string, options?: ErrorOptions);
-}
-/** Error while validating checksum */
-export declare class ChecksumMismatchError extends UUError {
-    constructor(message: string, options?: ErrorOptions);
-}
-/** Error while migrating data */
-export declare class MigrationError extends UUError {
-    constructor(message: string, options?: ErrorOptions);
-}
-/** Error due to the platform, like using a feature that's not supported by the browser */
-export declare class PlatformError extends UUError {
-    constructor(message: string, options?: ErrorOptions);
-}

package/dist/lib/math.d.ts

@@ -1,81 +0,0 @@
-/**
- * @module lib/math  
- * This module contains various math functions - [see the documentation for more info](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#math)  
- */
-import type { Stringifiable } from "./types.js";
-/** Ensures the passed {@linkcode value} always stays between {@linkcode min} and {@linkcode max} */
-export declare function clamp(value: number, min: number, max: number): number;
-/** Ensures the passed {@linkcode value} always stays between 0 and {@linkcode max} */
-export declare function clamp(value: number, max: number): number;
-/**
- * Transforms the value parameter from the numerical range `range1min` to `range1max` to the numerical range `range2min` to `range2max`  
- * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.  
- */
-export declare function mapRange(value: number, range1min: number, range1max: number, range2min: number, range2max: number): number;
-/**
- * Transforms the value parameter from the numerical range `0` to `range1max` to the numerical range `0` to `range2max`  
- * For example, you can map the value 2 in the range of 0-5 to the range of 0-10 and you'd get a 4 as a result.  
- */
-export declare function mapRange(value: number, range1max: number, range2max: number): number;
-/**
- * Returns a random number between {@linkcode min} and {@linkcode max} (inclusive)  
- * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)  
- */
-export declare function randRange(min: number, max: number, enhancedEntropy?: boolean): number;
-/**
- * Returns a random number between 0 and {@linkcode max} (inclusive)  
- * Set {@linkcode enhancedEntropy} to true to use `crypto.getRandomValues()` for better cryptographic randomness (this also makes it take longer to generate)  
- */
-export declare function randRange(max: number, enhancedEntropy?: boolean): number;
-/**
- * Calculates the amount of digits in the given number - the given number or string will be passed to the `Number()` constructor.  
- * Returns NaN if the number is invalid.  
- * @param num The number to count the digits of  
- * @param withDecimals Whether to count the decimal places as well (defaults to true)  
- * @example ```ts  
- * digitCount();         // NaN  
- * digitCount(0);        // 1  
- * digitCount(123);      // 3  
- * digitCount(123.456);  // 6  
- * digitCount(Infinity); // Infinity  
- * ```  
- */
-export declare function digitCount(num: number | Stringifiable, withDecimals?: boolean): number;
-/**
- * Rounds {@linkcode num} to a fixed amount of decimal places, specified by {@linkcode fractionDigits} (supports negative values to round to the nearest power of 10).  
- * @example ```ts  
- * roundFixed(234.567, -2); // 200  
- * roundFixed(234.567, -1); // 230  
- * roundFixed(234.567, 0);  // 235  
- * roundFixed(234.567, 1);  // 234.6  
- * roundFixed(234.567, 2);  // 234.57  
- * roundFixed(234.567, 3);  // 234.567  
- * ```  
- */
-export declare function roundFixed(num: number, fractionDigits: number): number;
-/**
- * Checks if the {@linkcode bitSet} has the {@linkcode checkVal} set  
- * @example ```ts  
- * // the two vertically adjacent bits are tested for:  
- * bitSetHas(  
- *   0b1110,  
- *   0b0010,  
- * ); // true  
- *  
- * bitSetHas(  
- *   0b1110,  
- *   0b0001,  
- * ); // false  
- *  
- * // with TS enums (or JS maps):  
- * enum MyEnum {  
- *   A = 1, B = 2, C = 4,  
- *   D = 8, E = 16, F = 32,  
- * }  
- *  
- * const myBitSet = MyEnum.A | MyEnum.B;  
- * bitSetHas(myBitSet, MyEnum.B); // true  
- * bitSetHas(myBitSet, MyEnum.F); // false  
- * ```  
- */
-export declare function bitSetHas<TType extends number | bigint>(bitSet: TType, checkVal: TType): boolean;