@sv443-network/userutils 9.3.0 → 9.4.0

package/dist/index.js

@@ -1,6 +1,8 @@
 import { createNanoEvents } from 'nanoevents';
 
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -16,6 +18,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -248,16 +251,16 @@ function addGlobalStyle(style) {
 function preloadImages(srcUrls, rejects = false) {
   const promises = srcUrls.map((src) => new Promise((res, rej) => {
     const image = new Image();
-    image.src = src;
     image.addEventListener("load", () => res(image));
     image.addEventListener("error", (evt) => rejects && rej(evt));
+    image.src = src;
   }));
   return Promise.allSettled(promises);
 }
 function openInNewTab(href, background, additionalProps) {
-  var _a;
   try {
-    (_a = GM.openInTab) == null ? void 0 : _a.call(GM, href, background);
+    if (typeof window.GM === "object")
+      GM.openInTab(href, background);
   } catch (e) {
     const openElem = document.createElement("a");
     Object.assign(openElem, __spreadValues({
@@ -274,12 +277,17 @@ function openInNewTab(href, background, additionalProps) {
     });
     document.body.appendChild(openElem);
     openElem.click();
-    setTimeout(openElem.remove, 0);
+    setTimeout(() => {
+      try {
+        openElem.remove();
+      } catch (e2) {
+      }
+    }, 0);
   }
 }
 function interceptEvent(eventObject, eventName, predicate = () => true) {
   var _a;
-  if (((_a = GM == null ? undefined : GM.info) == null ? undefined : _a.scriptHandler) && GM.info.scriptHandler === "FireMonkey" && (eventObject === window || eventObject === getUnsafeWindow()))
+  if (typeof window.GM === "object" && ((_a = GM == null ? undefined : GM.info) == null ? undefined : _a.scriptHandler) && GM.info.scriptHandler === "FireMonkey" && (eventObject === window || eventObject === getUnsafeWindow()))
     throw new PlatformError("Intercepting window events is not supported on FireMonkey due to the isolated context the userscript runs in.");
   Error.stackTraceLimit = Math.max(Error.stackTraceLimit, 100);
   if (isNaN(Error.stackTraceLimit))
@@ -439,6 +447,8 @@ function computeHash(input, algorithm = "SHA-256") {
   });
 }
 function randomId(length = 16, radix = 16, enhancedEntropy = false, randomCase = true) {
+  if (length < 1)
+    throw new RangeError("The length argument must be at least 1");
   if (radix < 2 || radix > 36)
     throw new RangeError("The radix argument must be between 2 and 36");
   let arr = [];
@@ -783,7 +793,7 @@ var DataStoreSerializer = class _DataStoreSerializer {
   deserializePartial(stores, data) {
     return __async(this, null, function* () {
       const deserStores = typeof data === "string" ? JSON.parse(data) : data;
-      if (!Array.isArray(deserStores) || !deserStores.every(_DataStoreSerializer.isSerializedDataStore))
+      if (!Array.isArray(deserStores) || !deserStores.every(_DataStoreSerializer.isSerializedDataStoreObj))
         throw new TypeError("Invalid serialized data format! Expected an array of SerializedDataStore objects.");
       for (const storeData of deserStores.filter((s) => typeof stores === "function" ? stores(s.id) : stores.includes(s.id))) {
         const storeInst = this.stores.find((s) => s.id === storeData.id);
@@ -816,41 +826,59 @@ Has: ${checksum}`);
   /**
    * 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() {
+  loadStoresData(stores) {
     return __async(this, null, function* () {
-      return Promise.allSettled(this.stores.map(
-        (store) => __async(this, null, function* () {
+      return Promise.allSettled(
+        this.getStoresFiltered(stores).map((store) => __async(this, null, function* () {
           return {
             id: store.id,
             data: yield store.loadData()
           };
-        })
-      ));
+        }))
+      );
     });
   }
-  /** Resets the persistent data of the DataStore instances to their default values. */
-  resetStoresData() {
+  /**
+   * 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) {
     return __async(this, null, function* () {
-      return Promise.allSettled(this.stores.map((store) => store.saveDefaultData()));
+      return Promise.allSettled(
+        this.getStoresFiltered(stores).map((store) => store.saveDefaultData())
+      );
     });
   }
   /**
    * Deletes the persistent data of the DataStore instances.  
-   * Leaves the in-memory data untouched.
+   * 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() {
+  deleteStoresData(stores) {
     return __async(this, null, function* () {
-      return Promise.allSettled(this.stores.map((store) => store.deleteData()));
+      return Promise.allSettled(
+        this.getStoresFiltered(stores).map((store) => store.deleteData())
+      );
     });
   }
+  /** Checks if a given value is an array of SerializedDataStore objects */
+  static isSerializedDataStoreObjArray(obj) {
+    return Array.isArray(obj) && obj.every((o) => typeof o === "object" && o !== null && "id" in o && "data" in o && "formatVersion" in o && "encoded" in o);
+  }
   /** Checks if a given value is a SerializedDataStore object */
-  static isSerializedDataStore(obj) {
+  static isSerializedDataStoreObj(obj) {
     return typeof obj === "object" && obj !== null && "id" in obj && "data" in obj && "formatVersion" in obj && "encoded" in obj;
   }
+  /** Returns the DataStore instances whose IDs match the provided array or function */
+  getStoresFiltered(stores) {
+    return this.stores.filter((s) => typeof stores === "undefined" ? true : Array.isArray(stores) ? stores.includes(s.id) : stores(s.id));
+  }
 };
 var NanoEmitter = class {
+  /** Creates a new instance of NanoEmitter - a lightweight event emitter with helper methods and a strongly typed event map */
   constructor(options = {}) {
     __publicField(this, "events", createNanoEvents());
     __publicField(this, "eventUnsubscribes", []);
@@ -859,7 +887,27 @@ var NanoEmitter = class {
       publicEmit: false
     }, options);
   }
-  /** Subscribes to an event - returns a function that unsubscribes the event listener */
+  /**
+   * 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(event, cb) {
     let unsub;
     const unsubProxy = () => {
@@ -872,19 +920,43 @@ var NanoEmitter = class {
     this.eventUnsubscribes.push(unsub);
     return unsubProxy;
   }
-  /** Subscribes to an event and calls the callback or resolves the Promise only once */
+  /**
+   * 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(event, cb) {
     return new Promise((resolve) => {
       let unsub;
       const onceProxy = (...args) => {
-        unsub();
         cb == null ? undefined : cb(...args);
+        unsub == null ? undefined : unsub();
         resolve(args);
       };
-      unsub = this.on(event, onceProxy);
+      unsub = this.events.on(event, onceProxy);
+      this.eventUnsubscribes.push(unsub);
     });
   }
-  /** Emits an event on this instance - Needs `publicEmit` to be set to true in the constructor! */
+  /**
+   * 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(event, ...args) {
     if (this.emitterOptions.publicEmit) {
       this.events.emit(event, ...args);
@@ -892,7 +964,7 @@ var NanoEmitter = class {
     }
     return false;
   }
-  /** Unsubscribes all event listeners */
+  /** Unsubscribes all event listeners from this instance */
   unsubscribeAll() {
     for (const unsub of this.eventUnsubscribes)
       unsub();
@@ -932,6 +1004,10 @@ var Debouncer = class extends NanoEmitter {
   removeAllListeners() {
     this.listeners = [];
   }
+  /** Returns all registered listeners */
+  getListeners() {
+    return this.listeners;
+  }
   //#region timeout
   /** Sets the timeout for the debouncer */
   setTimeout(timeout) {
@@ -960,7 +1036,7 @@ var Debouncer = class extends NanoEmitter {
     const cl = (...a) => {
       this.queuedCall = undefined;
       this.emit("call", ...a);
-      this.listeners.forEach((l) => l.apply(this, a));
+      this.listeners.forEach((l) => l.call(this, ...a));
     };
     const setRepeatTimeout = () => {
       this.activeTimeout = setTimeout(() => {
@@ -1434,8 +1510,6 @@ function autoPlural(term, num, pluralType = "auto") {
       return `${term}${n === 1 ? "" : "s"}`;
     case "-ies":
       return `${String(term).slice(0, -1)}${n === 1 ? "y" : "ies"}`;
-    default:
-      return String(term);
   }
 }
 function insertValues(input, ...values) {
@@ -1494,6 +1568,112 @@ function purifyObj(obj) {
   return Object.assign(/* @__PURE__ */ Object.create(null), obj);
 }
 
+// lib/Mixins.ts
+var Mixins = class {
+  /**
+   * Creates a new Mixins instance.
+   * @param config Configuration object to customize the behavior.
+   */
+  constructor(config = {}) {
+    /** List of all registered mixins */
+    __publicField(this, "mixins", []);
+    /** Default configuration object for mixins */
+    __publicField(this, "defaultMixinCfg");
+    /** Whether the priorities should auto-increment if not specified */
+    __publicField(this, "autoIncPrioEnabled");
+    /** The current auto-increment priority counter */
+    __publicField(this, "autoIncPrioCounter", /* @__PURE__ */ new Map());
+    var _a, _b, _c;
+    this.defaultMixinCfg = purifyObj({
+      priority: (_a = config.defaultPriority) != null ? _a : 0,
+      stopPropagation: (_b = config.defaultStopPropagation) != null ? _b : false,
+      signal: config.defaultSignal
+    });
+    this.autoIncPrioEnabled = (_c = config.autoIncrementPriority) != null ? _c : false;
+  }
+  //#region public
+  /**
+   * Adds a mixin function to the given {@linkcode mixinKey}.  
+   * If no priority is specified, it will be calculated via the protected method {@linkcode calcPriority()} based on the constructor configuration, or fall back to the default priority.
+   * @param mixinKey The key to identify the mixin function.
+   * @param mixinFn The function to be called to apply the mixin. The first argument is the input value, the second argument is the context object (if any).
+   * @param config Configuration object to customize the mixin behavior, or just the priority if a number is passed.
+   * @returns Returns a cleanup function, to be called when this mixin is no longer needed.
+   */
+  add(mixinKey, mixinFn, config = purifyObj({})) {
+    const calcPrio = typeof config === "number" ? config : this.calcPriority(mixinKey, config);
+    const mixin = purifyObj(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, this.defaultMixinCfg), {
+      key: mixinKey,
+      fn: mixinFn
+    }), typeof config === "object" ? config : {}), typeof calcPrio === "number" && !isNaN(calcPrio) ? { priority: calcPrio } : {}));
+    this.mixins.push(mixin);
+    const rem = () => {
+      this.mixins = this.mixins.filter((m) => m !== mixin);
+    };
+    if (mixin.signal)
+      mixin.signal.addEventListener("abort", rem, { once: true });
+    return rem;
+  }
+  /** Returns a list of all added mixins with their keys and configuration objects, but not their functions */
+  list() {
+    return this.mixins.map((_a) => {
+      var _b = _a, rest = __objRest(_b, ["fn"]);
+      return rest;
+    });
+  }
+  /**
+   * Applies all mixins with the given key to the input value, respecting the priority and stopPropagation settings.  
+   * If additional context is set in the MixinMap, it will need to be passed as the third argument.  
+   * @returns The modified value after all mixins have been applied.
+   */
+  resolve(mixinKey, inputValue, ...inputCtx) {
+    const mixins = this.mixins.filter((m) => m.key === mixinKey);
+    const sortedMixins = [...mixins].sort((a, b) => b.priority - a.priority);
+    let result = inputValue;
+    for (let i = 0; i < sortedMixins.length; i++) {
+      const mixin = sortedMixins[i];
+      result = mixin.fn(result, ...inputCtx);
+      if (result instanceof Promise) {
+        return (() => __async(this, null, function* () {
+          result = yield result;
+          if (mixin.stopPropagation)
+            return result;
+          for (let j = i + 1; j < sortedMixins.length; j++) {
+            const mixin2 = sortedMixins[j];
+            result = yield mixin2.fn(result, ...inputCtx);
+            if (mixin2.stopPropagation)
+              break;
+          }
+          return result;
+        }))();
+      } else if (mixin.stopPropagation)
+        break;
+    }
+    return result;
+  }
+  //#region protected
+  /** Calculates the priority for a mixin based on the given configuration and the current auto-increment state of the instance */
+  calcPriority(mixinKey, config) {
+    var _a;
+    if (config.priority !== undefined)
+      return undefined;
+    if (!this.autoIncPrioEnabled)
+      return (_a = config.priority) != null ? _a : this.defaultMixinCfg.priority;
+    if (!this.autoIncPrioCounter.has(mixinKey))
+      this.autoIncPrioCounter.set(mixinKey, this.defaultMixinCfg.priority);
+    let prio = this.autoIncPrioCounter.get(mixinKey);
+    while (this.mixins.some((m) => m.key === mixinKey && m.priority === prio))
+      prio++;
+    this.autoIncPrioCounter.set(mixinKey, prio + 1);
+    return prio;
+  }
+  /** Removes all mixins with the given key */
+  removeAll(mixinKey) {
+    this.mixins.filter((m) => m.key === mixinKey);
+    this.mixins = this.mixins.filter((m) => m.key !== mixinKey);
+  }
+};
+
 // lib/SelectorObserver.ts
 var SelectorObserver = class {
   constructor(baseElement, options = {}) {
@@ -1751,15 +1931,15 @@ function getFallbackLanguage() {
   return fallbackLang;
 }
 function addTransform(transform) {
-  const [pattern, fn] = transform;
+  const [regex, fn] = transform;
   valTransforms.push({
     fn,
-    regex: typeof pattern === "string" ? new RegExp(pattern, "gm") : pattern
+    regex
   });
 }
 function deleteTransform(patternOrFn) {
   const idx = valTransforms.findIndex(
-    (t) => typeof patternOrFn === "function" ? t.fn === patternOrFn : typeof patternOrFn === "string" ? t.regex.source === patternOrFn : t.regex === patternOrFn
+    (t) => typeof patternOrFn === "function" ? t.fn === patternOrFn : t.regex === patternOrFn
   );
   if (idx !== -1) {
     valTransforms.splice(idx, 1);
@@ -1830,4 +2010,4 @@ var tr = {
   }
 };
 
-export { ChecksumMismatchError, DataStore, DataStoreSerializer, Debouncer, Dialog, MigrationError, NanoEmitter, PlatformError, SelectorObserver, UUError, addGlobalStyle, addParent, autoPlural, bitSetHas, clamp, compress, computeHash, consumeGen, consumeStringGen, currentDialogId, darkenColor, debounce, decompress, defaultDialogCss, defaultStrings, digitCount, fetchAdvanced, getListLength, getSiblingsFrame, getUnsafeWindow, hexToRgb, insertValues, interceptEvent, interceptWindowEvent, isDomLoaded, isScrollable, lightenColor, mapRange, observeElementProp, onDomLoad, openDialogs, openInNewTab, pauseFor, preloadImages, probeElementStyle, purifyObj, randRange, randomId, randomItem, randomItemIndex, randomizeArray, rgbToHex, roundFixed, setInnerHtmlUnsafe, takeRandomItem, tr };
+export { ChecksumMismatchError, DataStore, DataStoreSerializer, Debouncer, Dialog, MigrationError, Mixins, NanoEmitter, PlatformError, SelectorObserver, UUError, addGlobalStyle, addParent, autoPlural, bitSetHas, clamp, compress, computeHash, consumeGen, consumeStringGen, currentDialogId, darkenColor, debounce, decompress, defaultDialogCss, defaultStrings, digitCount, fetchAdvanced, getListLength, getSiblingsFrame, getUnsafeWindow, hexToRgb, insertValues, interceptEvent, interceptWindowEvent, isDomLoaded, isScrollable, lightenColor, mapRange, observeElementProp, onDomLoad, openDialogs, openInNewTab, pauseFor, preloadImages, probeElementStyle, purifyObj, randRange, randomId, randomItem, randomItemIndex, randomizeArray, rgbToHex, roundFixed, setInnerHtmlUnsafe, takeRandomItem, tr };

package/dist/lib/DataStoreSerializer.d.ts

@@ -4,9 +4,9 @@
  */
 import type { DataStore } from "./DataStore.js";
 export type DataStoreSerializerOptions = {
-    /** Whether to add a checksum to the exported data */
+    /** 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) */
+    /** 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 */
@@ -29,6 +29,8 @@ export type LoadStoresDataResult = {
     /** 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.  
  *  
@@ -49,21 +51,21 @@ export declare class DataStoreSerializer {
      * @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: string[] | ((id: string) => boolean), useEncoding?: boolean, stringified?: true): Promise<string>;
+    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: string[] | ((id: string) => boolean), useEncoding?: boolean, stringified?: false): Promise<SerializedDataStore[]>;
+    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: string[] | ((id: string) => boolean), useEncoding?: boolean, stringified?: boolean): Promise<string | SerializedDataStore[]>;
+    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  
@@ -80,7 +82,7 @@ export declare class DataStoreSerializer {
      * 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: string[] | ((id: string) => boolean), data: string | SerializedDataStore[]): Promise<void>;
+    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.  
@@ -89,16 +91,25 @@ export declare class DataStoreSerializer {
     /**
      * 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(): Promise<PromiseSettledResult<LoadStoresDataResult>[]>;
-    /** Resets the persistent data of the DataStore instances to their default values. */
-    resetStoresData(): Promise<PromiseSettledResult<void>[]>;
+    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(): Promise<PromiseSettledResult<void>[]>;
+    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 isSerializedDataStore(obj: unknown): obj is SerializedDataStore;
+    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

@@ -60,6 +60,8 @@ export declare class Debouncer<TFunc extends AnyFunc> extends NanoEmitter<Deboun
     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 */

package/dist/lib/Mixins.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @module lib/Mixins  
+ * Allows for defining and applying mixin functions to allow multiple sources to modify a value in a controlled way.  
+ */
+import type { Prettify } from "./types.js";
+/** Full mixin object (either sync or async), as it is stored in the instance's mixin array. */
+export type MixinObj<TArg, TCtx> = Prettify<MixinObjSync<TArg, TCtx> | MixinObjAsync<TArg, TCtx>>;
+/** Asynchronous mixin object, as it is stored in the instance's mixin array. */
+export type MixinObjSync<TArg, TCtx> = Prettify<{
+    /** The mixin function */
+    fn: (arg: TArg, ctx?: TCtx) => TArg;
+} & MixinObjBase>;
+/** Synchronous mixin object, as it is stored in the instance's mixin array. */
+export type MixinObjAsync<TArg, TCtx> = Prettify<{
+    /** The mixin function */
+    fn: (arg: TArg, ctx?: TCtx) => TArg | Promise<TArg>;
+} & MixinObjBase>;
+/** Base type for mixin objects */
+type MixinObjBase = Prettify<{
+    /** The public identifier key (purpose) of the mixin */
+    key: string;
+} & MixinConfig>;
+/** Configuration object for a mixin function */
+export type MixinConfig = {
+    /** The higher, the earlier the mixin will be applied. Supports floating-point and negative numbers too. 0 by default. */
+    priority: number;
+    /** If true, no further mixins will be applied after this one. */
+    stopPropagation: boolean;
+    /** If set, the mixin will only be applied if the given signal is not aborted. */
+    signal?: AbortSignal;
+};
+/** Configuration object for the Mixins class */
+export type MixinsConstructorConfig = {
+    /**
+     * If true, when no priority is specified, an auto-incrementing integer priority will be used, starting at `defaultPriority` or 0 (unique per mixin key). Defaults to false.  
+     * If a priority value is already used, it will be incremented until a unique value is found.  
+     * This is useful to ensure that mixins are applied in the order they were added, even if they don't specify a priority.  
+     * It also allows for a finer level of interjection when the priority is a floating point number.  
+     */
+    autoIncrementPriority: boolean;
+    /** The default priority for mixins that do not specify one. Defaults to 0. */
+    defaultPriority: number;
+    /** The default stopPropagation value for mixins that do not specify one. Defaults to false. */
+    defaultStopPropagation: boolean;
+    /** The default AbortSignal for mixins that do not specify one. Defaults to undefined. */
+    defaultSignal?: AbortSignal;
+};
+/**
+ * The mixin class allows for defining and applying mixin functions to allow multiple sources to modify values in a controlled way.  
+ * Mixins are identified via their string key and can be added with {@linkcode add()}  
+ * When calling {@linkcode resolve()}, all registered mixin functions with the same key will be applied to the input value in the order of their priority.  
+ * If a mixin has the stopPropagation flag set to true, no further mixins will be applied after it.  
+ * @template TMixinMap A map of mixin keys to their respective function signatures. The first argument of the function is the input value, the second argument is an optional context object. If it is defined here, it must be passed as the third argument in {@linkcode resolve()}.  
+ * @example ```ts  
+ * const ac = new AbortController();  
+ * const { abort: removeAllMixins } = ac;  
+ *  
+ * const mathMixins = new Mixins<{  
+ *   // supports sync and async functions:  
+ *   foo: (val: number, ctx: { baz: string }) => Promise<number>;  
+ *   // first argument and return value have to be of the same type:  
+ *   bar: (val: bigint) => bigint;  
+ *   // ...  
+ * }>({  
+ *   autoIncrementPriority: true,  
+ *   defaultPriority: 0,  
+ *   defaultSignal: ac.signal,  
+ * });  
+ *  
+ * // will be applied last due to base priority of 0:  
+ * mathMixins.add("foo", (val, ctx) => Promise.resolve(val * 2 + ctx.baz.length));  
+ * // will be applied second due to manually set priority of 1:  
+ * mathMixins.add("foo", (val) => val + 1, { priority: 1 });  
+ * // will be applied first, even though the above ones were called first, because of the auto-incrementing priority of 2:  
+ * mathMixins.add("foo", (val) => val / 2);  
+ *  
+ * const result = await mathMixins.resolve("foo", 10, { baz: "this has a length of 23" });  
+ * // order of application:  
+ * // input value: 10  
+ * // 10 / 2 = 5  
+ * // 5 + 1 = 6  
+ * // 6 * 2 + 23 = 35  
+ * // result = 35  
+ *  
+ * // removes all mixins added without a `signal` property:  
+ * removeAllMixins();  
+ * ```  
+ */
+export declare class Mixins<TMixinMap extends Record<string, (arg: any, ctx?: any) => any>, TMixinKey extends Extract<keyof TMixinMap, string> = Extract<keyof TMixinMap, string>> {
+    /** List of all registered mixins */
+    protected mixins: MixinObj<any, any>[];
+    /** Default configuration object for mixins */
+    protected readonly defaultMixinCfg: MixinConfig;
+    /** Whether the priorities should auto-increment if not specified */
+    protected readonly autoIncPrioEnabled: boolean;
+    /** The current auto-increment priority counter */
+    protected autoIncPrioCounter: Map<TMixinKey, number>;
+    /**
+     * Creates a new Mixins instance.  
+     * @param config Configuration object to customize the behavior.  
+     */
+    constructor(config?: Partial<MixinsConstructorConfig>);
+    /**
+     * Adds a mixin function to the given {@linkcode mixinKey}.  
+     * If no priority is specified, it will be calculated via the protected method {@linkcode calcPriority()} based on the constructor configuration, or fall back to the default priority.  
+     * @param mixinKey The key to identify the mixin function.  
+     * @param mixinFn The function to be called to apply the mixin. The first argument is the input value, the second argument is the context object (if any).  
+     * @param config Configuration object to customize the mixin behavior, or just the priority if a number is passed.  
+     * @returns Returns a cleanup function, to be called when this mixin is no longer needed.  
+     */
+    add<TKey extends TMixinKey, TArg extends Parameters<TMixinMap[TKey]>[0], TCtx extends Parameters<TMixinMap[TKey]>[1]>(mixinKey: TKey, mixinFn: (arg: TArg, ...ctx: TCtx extends undefined ? [void] : [TCtx]) => ReturnType<TMixinMap[TKey]> extends Promise<any> ? ReturnType<TMixinMap[TKey]> | Awaited<ReturnType<TMixinMap[TKey]>> : ReturnType<TMixinMap[TKey]>, config?: Partial<MixinConfig> | number): () => void;
+    /** Returns a list of all added mixins with their keys and configuration objects, but not their functions */
+    list(): ({
+        key: string;
+    } & MixinConfig)[];
+    /**
+     * Applies all mixins with the given key to the input value, respecting the priority and stopPropagation settings.  
+     * If additional context is set in the MixinMap, it will need to be passed as the third argument.  
+     * @returns The modified value after all mixins have been applied.  
+     */
+    resolve<TKey extends TMixinKey, TArg extends Parameters<TMixinMap[TKey]>[0], TCtx extends Parameters<TMixinMap[TKey]>[1]>(mixinKey: TKey, inputValue: TArg, ...inputCtx: TCtx extends undefined ? [void] : [TCtx]): ReturnType<TMixinMap[TKey]> extends Promise<any> ? ReturnType<TMixinMap[TKey]> : ReturnType<TMixinMap[TKey]>;
+    /** Calculates the priority for a mixin based on the given configuration and the current auto-increment state of the instance */
+    protected calcPriority(mixinKey: TMixinKey, config: Partial<MixinConfig>): number | undefined;
+    /** Removes all mixins with the given key */
+    protected removeAll(mixinKey: TMixinKey): void;
+}
+export {};