obsidian-dev-utils 22.1.1-beta.21 → 22.1.1-beta.22

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 22.1.1-beta.22
+
+- Subscribe once
+- Add once
+- Add plugin events
+- AsyncEvents
+- More tsdocs links
+
 ## 22.1.1-beta.21
 
 - Revert underscore logic to fix TS6133

package/dist/lib/cjs/Array.cjs

@@ -0,0 +1,48 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;const originalRequire=require;if(originalRequire&&!originalRequire.__isPatched){require=Object.assign(id=>requirePatched(id),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>{const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};return browserProcess},"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id){const module=originalRequire?.(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Array_exports = {};
+__export(Array_exports, {
+  filterInPlace: () => filterInPlace
+});
+module.exports = __toCommonJS(Array_exports);
+function filterInPlace(arr, predicate) {
+  let writeIndex = 0;
+  for (let readIndex = 0; readIndex < arr.length; readIndex++) {
+    if (!(readIndex in arr)) {
+      continue;
+    }
+    const current = arr[readIndex];
+    if (predicate(current, readIndex, arr)) {
+      arr[writeIndex++] = current;
+    }
+  }
+  arr.length = writeIndex;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterInPlace
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL0FycmF5LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEZpbHRlciBhbiBhcnJheSBpbiBwbGFjZS5cbiAqXG4gKiBAcGFyYW0gYXJyIC0gVGhlIGFycmF5IHRvIGZpbHRlci5cbiAqIEBwYXJhbSBwcmVkaWNhdGUgLSBUaGUgcHJlZGljYXRlIHRvIGZpbHRlciB0aGUgYXJyYXkuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmaWx0ZXJJblBsYWNlPFQ+KGFycjogVFtdLCBwcmVkaWNhdGU6ICh2YWx1ZTogVCwgaW5kZXg6IG51bWJlciwgYXJyYXk6IFRbXSkgPT4gYm9vbGVhbik6IHZvaWQge1xuICBsZXQgd3JpdGVJbmRleCA9IDA7XG4gIGZvciAobGV0IHJlYWRJbmRleCA9IDA7IHJlYWRJbmRleCA8IGFyci5sZW5ndGg7IHJlYWRJbmRleCsrKSB7XG4gICAgaWYgKCEocmVhZEluZGV4IGluIGFycikpIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cblxuICAgIGNvbnN0IGN1cnJlbnQgPSBhcnJbcmVhZEluZGV4XSBhcyBUO1xuICAgIGlmIChwcmVkaWNhdGUoY3VycmVudCwgcmVhZEluZGV4LCBhcnIpKSB7XG4gICAgICBhcnJbd3JpdGVJbmRleCsrXSA9IGN1cnJlbnQ7XG4gICAgfVxuICB9XG4gIGFyci5sZW5ndGggPSB3cml0ZUluZGV4O1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFNTyxTQUFTLGNBQWlCLEtBQVUsV0FBbUU7QUFDNUcsTUFBSSxhQUFhO0FBQ2pCLFdBQVMsWUFBWSxHQUFHLFlBQVksSUFBSSxRQUFRLGFBQWE7QUFDM0QsUUFBSSxFQUFFLGFBQWEsTUFBTTtBQUN2QjtBQUFBLElBQ0Y7QUFFQSxVQUFNLFVBQVUsSUFBSSxTQUFTO0FBQzdCLFFBQUksVUFBVSxTQUFTLFdBQVcsR0FBRyxHQUFHO0FBQ3RDLFVBQUksWUFBWSxJQUFJO0FBQUEsSUFDdEI7QUFBQSxFQUNGO0FBQ0EsTUFBSSxTQUFTO0FBQ2Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/cjs/Array.d.cts

@@ -0,0 +1,7 @@
+/**
+ * Filter an array in place.
+ *
+ * @param arr - The array to filter.
+ * @param predicate - The predicate to filter the array.
+ */
+export declare function filterInPlace<T>(arr: T[], predicate: (value: T, index: number, array: T[]) => boolean): void;

package/dist/lib/cjs/AsyncEvents.cjs

@@ -0,0 +1,216 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;const originalRequire=require;if(originalRequire&&!originalRequire.__isPatched){require=Object.assign(id=>requirePatched(id),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault:__name(()=>extractDefault,"__extractDefault"),process:__name(()=>{const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};return browserProcess},"process")};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&module.default?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id){const module=originalRequire?.(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AsyncEvents_exports = {};
+__export(AsyncEvents_exports, {
+  AsyncEvents: () => AsyncEvents
+});
+module.exports = __toCommonJS(AsyncEvents_exports);
+var import_Array = require('./Array.cjs');
+class AsyncEvents {
+  eventRefsMap = /* @__PURE__ */ new Map();
+  /**
+   * Remove an event listener.
+   *
+   * @param name - The name of the event.
+   * @param callback - The callback to remove.
+   *
+   * @example
+   * ```ts
+   * events.off('my-event', myListener);
+   * ```
+   *
+   * @public
+   */
+  off(name, callback) {
+    const eventRefs = this.eventRefsMap.get(name);
+    if (!eventRefs) {
+      return;
+    }
+    (0, import_Array.filterInPlace)(eventRefs, (eventRef) => eventRef.callback !== callback);
+    if (eventRefs.length === 0) {
+      this.eventRefsMap.delete(name);
+    }
+  }
+  /**
+   * Remove an event listener by reference.
+   *
+   * @param eventRef - The reference to the event listener.
+   *
+   * @example
+   * ```ts
+   * events.offref(myRef);
+   * ```
+   *
+   * @public
+   */
+  offref(eventRef) {
+    const eventRefs = this.eventRefsMap.get(eventRef.name);
+    if (!eventRefs) {
+      return;
+    }
+    (0, import_Array.filterInPlace)(eventRefs, (storedEventRef) => storedEventRef !== eventRef);
+    if (eventRefs.length === 0) {
+      this.eventRefsMap.delete(eventRef.name);
+    }
+  }
+  /**
+   * Add an event listener.
+   *
+   * @param name - The name of the event.
+   * @param callback - The callback to call when the event is triggered.
+   * @param thisArg - The context passed as `this` to the `callback`.
+   * @returns A reference to the event listener.
+   *
+   * @example
+   * ```ts
+   * events.on('my-event', async (arg1, arg2) => {
+   *     await sleep(100);
+   *     console.log(arg1, arg2);
+   * });
+   * ```
+   *
+   * @public
+   */
+  on(name, callback, thisArg) {
+    let eventRefs = this.eventRefsMap.get(name);
+    if (!eventRefs) {
+      eventRefs = [];
+      this.eventRefsMap.set(name, eventRefs);
+    }
+    const eventRef = {
+      asyncEvents: this,
+      callback,
+      name,
+      thisArg
+    };
+    eventRefs.push(eventRef);
+    return eventRef;
+  }
+  /**
+   * Add an event listener that will be triggered only once.
+   *
+   * @param name - The name of the event.
+   * @param callback - The callback to call when the event is triggered.
+   * @param thisArg - The context passed as `this` to the `callback`.
+   * @returns A reference to the event listener.
+   *
+   * @example
+   * ```ts
+   * events.once('my-event', async (arg1, arg2) => {
+   *     await sleep(100);
+   *     console.log(arg1, arg2);
+   * });
+   * ```
+   *
+   * @public
+   */
+  once(name, callback, thisArg) {
+    const originalEventRef = this.on(name, callback, thisArg);
+    const cleanupEventRef = this.on(name, () => {
+      this.offref(originalEventRef);
+      this.offref(cleanupEventRef);
+    });
+    return originalEventRef;
+  }
+  /**
+   * Trigger an event, executing all the listeners in order even if some of them throw an error.
+   *
+   * @param name - The name of the event.
+   * @param args - The data to pass to the event listeners.
+   *
+   * @example
+   * ```ts
+   * events.trigger('my-event', 'arg1', 'arg2');
+   * ```
+   *
+   * @public
+   */
+  trigger(name, ...args) {
+    const eventRefs = this.eventRefsMap.get(name) ?? [];
+    for (const eventRef of eventRefs.slice()) {
+      this.tryTrigger(eventRef, args);
+    }
+  }
+  /**
+   * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+   *
+   * @param name - The name of the event.
+   * @param args - The data to pass to the event listeners.
+   *
+   * @public
+   */
+  async triggerAsync(name, ...args) {
+    const eventRefs = this.eventRefsMap.get(name) ?? [];
+    for (const eventRef of eventRefs.slice()) {
+      await this.tryTriggerAsync(eventRef, args);
+    }
+  }
+  /**
+   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.
+   *
+   * @param eventRef - The event reference.
+   * @param args - The data to pass to the event listeners.
+   *
+   * @example
+   * ```ts
+   * events.tryTrigger(myRef, ['arg1', 'arg2']);
+   * ```
+   *
+   * @public
+   */
+  tryTrigger(eventRef, args) {
+    try {
+      eventRef.callback.apply(eventRef.thisArg, args);
+    } catch (e) {
+      setTimeout(() => {
+        throw e;
+      }, 0);
+    }
+  }
+  /**
+   * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+   *
+   * @param eventRef - The event reference.
+   * @param args - The data to pass to the event listeners.
+   *
+   * @public
+   */
+  async tryTriggerAsync(eventRef, args) {
+    try {
+      const result = eventRef.callback.call(eventRef.thisArg, ...args);
+      await result;
+    } catch (e) {
+      setTimeout(() => {
+        throw e;
+      }, 0);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncEvents
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/AsyncEvents.ts"],
  "sourcesContent": ["import type { Promisable } from 'type-fest';\n\nimport { filterInPlace } from './Array.ts';\n\n/**\n * Async event reference.\n */\nexport interface AsyncEventRef {\n  /**\n   * The event emitter.\n   */\n  asyncEvents: AsyncEvents;\n\n  /**\n   * The callback to call when the event is triggered.\n   */\n  callback: (...args: unknown[]) => Promisable<unknown>;\n\n  /**\n   * The name of the event.\n   */\n  name: string;\n\n  /**\n   * The context passed as `this` to the `callback`.\n   */\n  thisArg: unknown;\n}\n\n/**\n * Async event emitter implementation\n */\nexport class AsyncEvents {\n  private eventRefsMap = new Map<string, AsyncEventRef[]>();\n\n  /**\n   * Remove an event listener.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to remove.\n   *\n   * @example\n   * ```ts\n   * events.off('my-event', myListener);\n   * ```\n   *\n   * @public\n   */\n  public off(name: string, callback: (...args: unknown[]) => Promisable<unknown>): void {\n    const eventRefs = this.eventRefsMap.get(name);\n    if (!eventRefs) {\n      return;\n    }\n\n    filterInPlace(eventRefs, (eventRef) => eventRef.callback !== callback);\n    if (eventRefs.length === 0) {\n      this.eventRefsMap.delete(name);\n    }\n  }\n\n  /**\n   * Remove an event listener by reference.\n   *\n   * @param eventRef - The reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.offref(myRef);\n   * ```\n   *\n   * @public\n   */\n  public offref(eventRef: AsyncEventRef): void {\n    const eventRefs = this.eventRefsMap.get(eventRef.name);\n    if (!eventRefs) {\n      return;\n    }\n\n    filterInPlace(eventRefs, (storedEventRef) => storedEventRef !== eventRef);\n    if (eventRefs.length === 0) {\n      this.eventRefsMap.delete(eventRef.name);\n    }\n  }\n\n  /**\n   * Add an event listener.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.on('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   *\n   * @public\n   */\n  public on(name: string, callback: (...args: unknown[]) => Promisable<unknown>, thisArg?: unknown): AsyncEventRef {\n    let eventRefs = this.eventRefsMap.get(name);\n    if (!eventRefs) {\n      eventRefs = [];\n      this.eventRefsMap.set(name, eventRefs);\n    }\n\n    const eventRef: AsyncEventRef = {\n      asyncEvents: this,\n      callback,\n      name,\n      thisArg\n    };\n    eventRefs.push(eventRef);\n    return eventRef;\n  }\n\n  /**\n   * Add an event listener that will be triggered only once.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to call when the event is triggered.\n   * @param thisArg - The context passed as `this` to the `callback`.\n   * @returns A reference to the event listener.\n   *\n   * @example\n   * ```ts\n   * events.once('my-event', async (arg1, arg2) => {\n   *     await sleep(100);\n   *     console.log(arg1, arg2);\n   * });\n   * ```\n   *\n   * @public\n   */\n  public once(name: string, callback: (...args: unknown[]) => Promisable<unknown>, thisArg?: unknown): AsyncEventRef {\n    const originalEventRef = this.on(name, callback, thisArg);\n    const cleanupEventRef = this.on(name, () => {\n      this.offref(originalEventRef);\n      this.offref(cleanupEventRef);\n    });\n    return originalEventRef;\n  }\n\n  /**\n   * Trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @example\n   * ```ts\n   * events.trigger('my-event', 'arg1', 'arg2');\n   * ```\n   *\n   * @public\n   */\n  public trigger(name: string, ...args: unknown[]): void {\n    const eventRefs = this.eventRefsMap.get(name) ?? [];\n    for (const eventRef of eventRefs.slice()) {\n      this.tryTrigger(eventRef, args);\n    }\n  }\n\n  /**\n   * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param name - The name of the event.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @public\n   */\n  public async triggerAsync(name: string, ...args: unknown[]): Promise<void> {\n    const eventRefs = this.eventRefsMap.get(name) ?? [];\n    for (const eventRef of eventRefs.slice()) {\n      await this.tryTriggerAsync(eventRef, args);\n    }\n  }\n\n  /**\n   * Try to trigger an event, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @example\n   * ```ts\n   * events.tryTrigger(myRef, ['arg1', 'arg2']);\n   * ```\n   *\n   * @public\n   */\n  public tryTrigger(eventRef: AsyncEventRef, args: unknown[]): void {\n    try {\n      eventRef.callback.apply(eventRef.thisArg, args);\n    } catch (e) {\n      setTimeout(() => {\n        throw e;\n      }, 0);\n    }\n  }\n\n  /**\n   * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.\n   *\n   * @param eventRef - The event reference.\n   * @param args - The data to pass to the event listeners.\n   *\n   * @public\n   */\n  public async tryTriggerAsync(eventRef: AsyncEventRef, args: unknown[]): Promise<void> {\n    try {\n      const result = eventRef.callback.call(eventRef.thisArg, ...args);\n      await (result as Promise<void>);\n    } catch (e) {\n      setTimeout(() => {\n        throw e;\n      }, 0);\n    }\n  }\n}\n\n/*\n\nVar fs = (function () {\n        return (\n          (e.prototype.offref = function (e) {\n          }),\n          (e.prototype.trigger = function (e) {\n            for (var t = [], n = 1; n < arguments.length; n++)\n              t[n - 1] = arguments[n];\n            var r = this._[e];\n            if (r) {\n              r = r.slice();\n              for (var a = 0; a < r.length; a++) this.tryTrigger(r[a], t);\n            }\n          }),\n          (e.prototype.tryTrigger = function (e, t) {\n            try {\n              e.fn.apply(e.ctx, t);\n            } catch (e) {\n              setTimeout(function () {\n                throw e;\n              }, 0);\n            }\n          }),\n          e\n        );\n      })();\n*/\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAA8B;AA8BvB,MAAM,YAAY;AAAA,EACf,eAAe,oBAAI,IAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAejD,IAAI,MAAc,UAA6D;AACpF,UAAM,YAAY,KAAK,aAAa,IAAI,IAAI;AAC5C,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AAEA,oCAAc,WAAW,CAAC,aAAa,SAAS,aAAa,QAAQ;AACrE,QAAI,UAAU,WAAW,GAAG;AAC1B,WAAK,aAAa,OAAO,IAAI;AAAA,IAC/B;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcO,OAAO,UAA+B;AAC3C,UAAM,YAAY,KAAK,aAAa,IAAI,SAAS,IAAI;AACrD,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AAEA,oCAAc,WAAW,CAAC,mBAAmB,mBAAmB,QAAQ;AACxE,QAAI,UAAU,WAAW,GAAG;AAC1B,WAAK,aAAa,OAAO,SAAS,IAAI;AAAA,IACxC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,GAAG,MAAc,UAAuD,SAAkC;AAC/G,QAAI,YAAY,KAAK,aAAa,IAAI,IAAI;AAC1C,QAAI,CAAC,WAAW;AACd,kBAAY,CAAC;AACb,WAAK,aAAa,IAAI,MAAM,SAAS;AAAA,IACvC;AAEA,UAAM,WAA0B;AAAA,MAC9B,aAAa;AAAA,MACb;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,cAAU,KAAK,QAAQ;AACvB,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBO,KAAK,MAAc,UAAuD,SAAkC;AACjH,UAAM,mBAAmB,KAAK,GAAG,MAAM,UAAU,OAAO;AACxD,UAAM,kBAAkB,KAAK,GAAG,MAAM,MAAM;AAC1C,WAAK,OAAO,gBAAgB;AAC5B,WAAK,OAAO,eAAe;AAAA,IAC7B,CAAC;AACD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeO,QAAQ,SAAiB,MAAuB;AACrD,UAAM,YAAY,KAAK,aAAa,IAAI,IAAI,KAAK,CAAC;AAClD,eAAW,YAAY,UAAU,MAAM,GAAG;AACxC,WAAK,WAAW,UAAU,IAAI;AAAA,IAChC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,aAAa,SAAiB,MAAgC;AACzE,UAAM,YAAY,KAAK,aAAa,IAAI,IAAI,KAAK,CAAC;AAClD,eAAW,YAAY,UAAU,MAAM,GAAG;AACxC,YAAM,KAAK,gBAAgB,UAAU,IAAI;AAAA,IAC3C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeO,WAAW,UAAyB,MAAuB;AAChE,QAAI;AACF,eAAS,SAAS,MAAM,SAAS,SAAS,IAAI;AAAA,IAChD,SAAS,GAAG;AACV,iBAAW,MAAM;AACf,cAAM;AAAA,MACR,GAAG,CAAC;AAAA,IACN;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,gBAAgB,UAAyB,MAAgC;AACpF,QAAI;AACF,YAAM,SAAS,SAAS,SAAS,KAAK,SAAS,SAAS,GAAG,IAAI;AAC/D,YAAO;AAAA,IACT,SAAS,GAAG;AACV,iBAAW,MAAM;AACf,cAAM;AAAA,MACR,GAAG,CAAC;AAAA,IACN;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/cjs/AsyncEvents.d.cts

@@ -0,0 +1,139 @@
+import type { Promisable } from 'type-fest';
+/**
+ * Async event reference.
+ */
+export interface AsyncEventRef {
+    /**
+     * The event emitter.
+     */
+    asyncEvents: AsyncEvents;
+    /**
+     * The callback to call when the event is triggered.
+     */
+    callback: (...args: unknown[]) => Promisable<unknown>;
+    /**
+     * The name of the event.
+     */
+    name: string;
+    /**
+     * The context passed as `this` to the `callback`.
+     */
+    thisArg: unknown;
+}
+/**
+ * Async event emitter implementation
+ */
+export declare class AsyncEvents {
+    private eventRefsMap;
+    /**
+     * Remove an event listener.
+     *
+     * @param name - The name of the event.
+     * @param callback - The callback to remove.
+     *
+     * @example
+     * ```ts
+     * events.off('my-event', myListener);
+     * ```
+     *
+     * @public
+     */
+    off(name: string, callback: (...args: unknown[]) => Promisable<unknown>): void;
+    /**
+     * Remove an event listener by reference.
+     *
+     * @param eventRef - The reference to the event listener.
+     *
+     * @example
+     * ```ts
+     * events.offref(myRef);
+     * ```
+     *
+     * @public
+     */
+    offref(eventRef: AsyncEventRef): void;
+    /**
+     * Add an event listener.
+     *
+     * @param name - The name of the event.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
+     * @returns A reference to the event listener.
+     *
+     * @example
+     * ```ts
+     * events.on('my-event', async (arg1, arg2) => {
+     *     await sleep(100);
+     *     console.log(arg1, arg2);
+     * });
+     * ```
+     *
+     * @public
+     */
+    on(name: string, callback: (...args: unknown[]) => Promisable<unknown>, thisArg?: unknown): AsyncEventRef;
+    /**
+     * Add an event listener that will be triggered only once.
+     *
+     * @param name - The name of the event.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
+     * @returns A reference to the event listener.
+     *
+     * @example
+     * ```ts
+     * events.once('my-event', async (arg1, arg2) => {
+     *     await sleep(100);
+     *     console.log(arg1, arg2);
+     * });
+     * ```
+     *
+     * @public
+     */
+    once(name: string, callback: (...args: unknown[]) => Promisable<unknown>, thisArg?: unknown): AsyncEventRef;
+    /**
+     * Trigger an event, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param name - The name of the event.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @example
+     * ```ts
+     * events.trigger('my-event', 'arg1', 'arg2');
+     * ```
+     *
+     * @public
+     */
+    trigger(name: string, ...args: unknown[]): void;
+    /**
+     * Trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param name - The name of the event.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @public
+     */
+    triggerAsync(name: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Try to trigger an event, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param eventRef - The event reference.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @example
+     * ```ts
+     * events.tryTrigger(myRef, ['arg1', 'arg2']);
+     * ```
+     *
+     * @public
+     */
+    tryTrigger(eventRef: AsyncEventRef, args: unknown[]): void;
+    /**
+     * Try to trigger an event asynchronously, executing all the listeners in order even if some of them throw an error.
+     *
+     * @param eventRef - The event reference.
+     * @param args - The data to pass to the event listeners.
+     *
+     * @public
+     */
+    tryTriggerAsync(eventRef: AsyncEventRef, args: unknown[]): Promise<void>;
+}

package/dist/lib/cjs/Blob.cjs

@@ -106,4 +106,4 @@ function isImageFile(file) {
   dataUrlToArrayBuffer,
   isImageFile
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL0Jsb2IudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uIEFzeW5jXG4gKiBDb250YWlucyB1dGlsaXR5IGZ1bmN0aW9ucyBmb3IgQmxvYiBvYmplY3RzLlxuICovXG5cbi8qKlxuICogQ29udmVydHMgYSB7QGxpbmsgQmxvYn0gb2JqZWN0IHRvIGFuIHtAbGluayBBcnJheUJ1ZmZlcn0uXG4gKlxuICogQHBhcmFtIGJsb2IgLSBUaGUgQmxvYiBvYmplY3QgdG8gY29udmVydC5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gYW4ge0BsaW5rIEFycmF5QnVmZmVyfS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGJsb2JUb0FycmF5QnVmZmVyKGJsb2I6IEJsb2IpOiBQcm9taXNlPEFycmF5QnVmZmVyPiB7XG4gIHJldHVybiBhd2FpdCBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4ge1xuICAgIGNvbnN0IHJlYWRlciA9IG5ldyBGaWxlUmVhZGVyKCk7XG4gICAgcmVhZGVyLmFkZEV2ZW50TGlzdGVuZXIoJ2xvYWRlbmQnLCBoYW5kbGVMb2FkRW5kKTtcbiAgICByZWFkZXIucmVhZEFzQXJyYXlCdWZmZXIoYmxvYik7XG5cbiAgICBmdW5jdGlvbiBoYW5kbGVMb2FkRW5kKCk6IHZvaWQge1xuICAgICAgcmVzb2x2ZShyZWFkZXIucmVzdWx0IGFzIEFycmF5QnVmZmVyKTtcbiAgICB9XG4gIH0pO1xufVxuXG4vKipcbiAqIENvbnZlcnRzIGEge0BsaW5rIEJsb2J9IG9iamVjdCB0byBhIGRhdGEgVVJMLlxuICpcbiAqIEBwYXJhbSBibG9iIC0gVGhlIEJsb2Igb2JqZWN0IHRvIGNvbnZlcnQuXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSB0aGF0IHJlc29sdmVzIHRvIGEgZGF0YSBVUkwuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBibG9iVG9EYXRhVXJsKGJsb2I6IEJsb2IpOiBQcm9taXNlPHN0cmluZz4ge1xuICByZXR1cm4gYXdhaXQgbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHtcbiAgICBjb25zdCByZWFkZXIgPSBuZXcgRmlsZVJlYWRlcigpO1xuICAgIHJlYWRlci5hZGRFdmVudExpc3RlbmVyKCdsb2FkZW5kJywgaGFuZGxlTG9hZEVuZCk7XG4gICAgcmVhZGVyLnJlYWRBc0RhdGFVUkwoYmxvYik7XG5cbiAgICBmdW5jdGlvbiBoYW5kbGVMb2FkRW5kKCk6IHZvaWQge1xuICAgICAgcmVzb2x2ZShyZWFkZXIucmVzdWx0IGFzIHN0cmluZyk7XG4gICAgfVxuICB9KTtcbn1cblxuLyoqXG4gKiBDb252ZXJ0cyBhIHtAbGluayBCbG9ifSBvYmplY3QgdG8gYSBKUEVHIEFycmF5QnVmZmVyIHdpdGggdGhlIHNwZWNpZmllZCBxdWFsaXR5LlxuICpcbiAqIEBwYXJhbSBibG9iIC0gVGhlIEJsb2Igb2JqZWN0IHRvIGNvbnZlcnQuXG4gKiBAcGFyYW0ganBlZ1F1YWxpdHkgLSBUaGUgcXVhbGl0eSBvZiB0aGUgSlBFRyBpbWFnZSAoMCB0byAxKS5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gYW4ge0BsaW5rIEFycmF5QnVmZmVyfS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGJsb2JUb0pwZWdBcnJheUJ1ZmZlcihibG9iOiBCbG9iLCBqcGVnUXVhbGl0eTogbnVtYmVyKTogUHJvbWlzZTxBcnJheUJ1ZmZlcj4ge1xuICBjb25zdCBkYXRhVXJsID0gYXdhaXQgYmxvYlRvRGF0YVVybChibG9iKTtcbiAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7XG4gICAgY29uc3QgaW1hZ2UgPSBuZXcgSW1hZ2UoKTtcbiAgICBpbWFnZS5hZGRFdmVudExpc3RlbmVyKCdsb2FkJywgaGFuZGxlTG9hZCk7XG4gICAgaW1hZ2Uuc3JjID0gZGF0YVVybDtcblxuICAgIGZ1bmN0aW9uIGhhbmRsZUxvYWQoKTogdm9pZCB7XG4gICAgICBjb25zdCBjYW52YXMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdjYW52YXMnKTtcbiAgICAgIGNvbnN0IGNvbnRleHQgPSBjYW52YXMuZ2V0Q29udGV4dCgnMmQnKTtcbiAgICAgIGlmICghY29udGV4dCkge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ0NvdWxkIG5vdCBnZXQgMkQgY29udGV4dC4nKTtcbiAgICAgIH1cbiAgICAgIGNvbnN0IGltYWdlV2lkdGggPSBpbWFnZS53aWR0aDtcbiAgICAgIGNvbnN0IGltYWdlSGVpZ2h0ID0gaW1hZ2UuaGVpZ2h0O1xuXG4gICAgICBjYW52YXMud2lkdGggPSBpbWFnZVdpZHRoO1xuICAgICAgY2FudmFzLmhlaWdodCA9IGltYWdlSGVpZ2h0O1xuXG4gICAgICBjb250ZXh0LmZpbGxTdHlsZSA9ICcjZmZmJztcbiAgICAgIGNvbnRleHQuZmlsbFJlY3QoMCwgMCwgaW1hZ2VXaWR0aCwgaW1hZ2VIZWlnaHQpO1xuICAgICAgY29udGV4dC5zYXZlKCk7XG5cbiAgICAgIGNvbnN0IEhBTEYgPSAwLjU7XG4gICAgICBjb250ZXh0LnRyYW5zbGF0ZShpbWFnZVdpZHRoICogSEFMRiwgaW1hZ2VIZWlnaHQgKiBIQUxGKTtcbiAgICAgIGNvbnRleHQuZHJhd0ltYWdlKGltYWdlLCAwLCAwLCBpbWFnZVdpZHRoLCBpbWFnZUhlaWdodCwgLWltYWdlV2lkdGggKiBIQUxGLCAtaW1hZ2VIZWlnaHQgKiBIQUxGLCBpbWFnZVdpZHRoLCBpbWFnZUhlaWdodCk7XG4gICAgICBjb250ZXh0LnJlc3RvcmUoKTtcblxuICAgICAgY29uc3QganBlZ0RhdGFVcmwgPSBjYW52YXMudG9EYXRhVVJMKCdpbWFnZS9qcGVnJywganBlZ1F1YWxpdHkpO1xuICAgICAgY29uc3QgYXJyYXlCdWZmZXIgPSBkYXRhVXJsVG9BcnJheUJ1ZmZlcihqcGVnRGF0YVVybCk7XG4gICAgICByZXNvbHZlKGFycmF5QnVmZmVyKTtcbiAgICB9XG4gIH0pO1xufVxuXG4vKipcbiAqIENvbnZlcnRzIGEgYmFzZTY0IGVuY29kZWQgc3RyaW5nIHRvIGFuIHtAbGluayBBcnJheUJ1ZmZlcn0uXG4gKlxuICogQHBhcmFtIGRhdGFVcmwgLSBUaGUgZGF0YSBVUkwgdG8gY29udmVydC5cbiAqIEByZXR1cm5zIFRoZSBkZWNvZGVkIEFycmF5QnVmZmVyLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZGF0YVVybFRvQXJyYXlCdWZmZXIoZGF0YVVybDogc3RyaW5nKTogQXJyYXlCdWZmZXIge1xuICBjb25zdCBwYXJ0cyA9IGRhdGFVcmwuc3BsaXQoJztiYXNlNjQsJyk7XG4gIGNvbnN0IGJhc2U2NCA9IHBhcnRzWzFdO1xuICBpZiAoIWJhc2U2NCkge1xuICAgIHRocm93IG5ldyBFcnJvcignSW52YWxpZCBkYXRhIFVSTCcpO1xuICB9XG5cbiAgY29uc3QgcmF3ID0gd2luZG93LmF0b2IoYmFzZTY0KTtcbiAgY29uc3QgcmF3TGVuZ3RoID0gcmF3Lmxlbmd0aDtcblxuICBjb25zdCB1SW50OEFycmF5ID0gbmV3IFVpbnQ4QXJyYXkocmF3TGVuZ3RoKTtcblxuICBmb3IgKGxldCBpID0gMDsgaSA8IHJhd0xlbmd0aDsgaSsrKSB7XG4gICAgdUludDhBcnJheVtpXSA9IHJhdy5jaGFyQ29kZUF0KGkpO1xuICB9XG4gIHJldHVybiB1SW50OEFycmF5LmJ1ZmZlcjtcbn1cblxuLyoqXG4gKiBDaGVja3MgaWYgYSBnaXZlbiBmaWxlIGlzIGFuIGltYWdlLlxuICpcbiAqIEBwYXJhbSBmaWxlIC0gVGhlIGZpbGUgdG8gY2hlY2suXG4gKiBAcmV0dXJucyBUcnVlIGlmIHRoZSBmaWxlIGlzIGFuIGltYWdlLCBmYWxzZSBvdGhlcndpc2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc0ltYWdlRmlsZShmaWxlOiBGaWxlKTogYm9vbGVhbiB7XG4gIHJldHVybiBmaWxlLnR5cGUuc3RhcnRzV2l0aCgnaW1hZ2UvJyk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBV0EsZUFBc0Isa0JBQWtCLE1BQWtDO0FBQ3hFLFNBQU8sTUFBTSxJQUFJLFFBQVEsQ0FBQyxZQUFZO0FBQ3BDLFVBQU0sU0FBUyxJQUFJLFdBQVc7QUFDOUIsV0FBTyxpQkFBaUIsV0FBVyxhQUFhO0FBQ2hELFdBQU8sa0JBQWtCLElBQUk7QUFFN0IsYUFBUyxnQkFBc0I7QUFDN0IsY0FBUSxPQUFPLE1BQXFCO0FBQUEsSUFDdEM7QUFBQSxFQUNGLENBQUM7QUFDSDtBQVFBLGVBQXNCLGNBQWMsTUFBNkI7QUFDL0QsU0FBTyxNQUFNLElBQUksUUFBUSxDQUFDLFlBQVk7QUFDcEMsVUFBTSxTQUFTLElBQUksV0FBVztBQUM5QixXQUFPLGlCQUFpQixXQUFXLGFBQWE7QUFDaEQsV0FBTyxjQUFjLElBQUk7QUFFekIsYUFBUyxnQkFBc0I7QUFDN0IsY0FBUSxPQUFPLE1BQWdCO0FBQUEsSUFDakM7QUFBQSxFQUNGLENBQUM7QUFDSDtBQVNBLGVBQXNCLHNCQUFzQixNQUFZLGFBQTJDO0FBQ2pHLFFBQU0sVUFBVSxNQUFNLGNBQWMsSUFBSTtBQUN4QyxTQUFPLElBQUksUUFBUSxDQUFDLFlBQVk7QUFDOUIsVUFBTSxRQUFRLElBQUksTUFBTTtBQUN4QixVQUFNLGlCQUFpQixRQUFRLFVBQVU7QUFDekMsVUFBTSxNQUFNO0FBRVosYUFBUyxhQUFtQjtBQUMxQixZQUFNLFNBQVMsU0FBUyxjQUFjLFFBQVE7QUFDOUMsWUFBTSxVQUFVLE9BQU8sV0FBVyxJQUFJO0FBQ3RDLFVBQUksQ0FBQyxTQUFTO0FBQ1osY0FBTSxJQUFJLE1BQU0sMkJBQTJCO0FBQUEsTUFDN0M7QUFDQSxZQUFNLGFBQWEsTUFBTTtBQUN6QixZQUFNLGNBQWMsTUFBTTtBQUUxQixhQUFPLFFBQVE7QUFDZixhQUFPLFNBQVM7QUFFaEIsY0FBUSxZQUFZO0FBQ3BCLGNBQVEsU0FBUyxHQUFHLEdBQUcsWUFBWSxXQUFXO0FBQzlDLGNBQVEsS0FBSztBQUViLFlBQU0sT0FBTztBQUNiLGNBQVEsVUFBVSxhQUFhLE1BQU0sY0FBYyxJQUFJO0FBQ3ZELGNBQVEsVUFBVSxPQUFPLEdBQUcsR0FBRyxZQUFZLGFBQWEsQ0FBQyxhQUFhLE1BQU0sQ0FBQyxjQUFjLE1BQU0sWUFBWSxXQUFXO0FBQ3hILGNBQVEsUUFBUTtBQUVoQixZQUFNLGNBQWMsT0FBTyxVQUFVLGNBQWMsV0FBVztBQUM5RCxZQUFNLGNBQWMscUJBQXFCLFdBQVc7QUFDcEQsY0FBUSxXQUFXO0FBQUEsSUFDckI7QUFBQSxFQUNGLENBQUM7QUFDSDtBQVFPLFNBQVMscUJBQXFCLFNBQThCO0FBQ2pFLFFBQU0sUUFBUSxRQUFRLE1BQU0sVUFBVTtBQUN0QyxRQUFNLFNBQVMsTUFBTSxDQUFDO0FBQ3RCLE1BQUksQ0FBQyxRQUFRO0FBQ1gsVUFBTSxJQUFJLE1BQU0sa0JBQWtCO0FBQUEsRUFDcEM7QUFFQSxRQUFNLE1BQU0sT0FBTyxLQUFLLE1BQU07QUFDOUIsUUFBTSxZQUFZLElBQUk7QUFFdEIsUUFBTSxhQUFhLElBQUksV0FBVyxTQUFTO0FBRTNDLFdBQVMsSUFBSSxHQUFHLElBQUksV0FBVyxLQUFLO0FBQ2xDLGVBQVcsQ0FBQyxJQUFJLElBQUksV0FBVyxDQUFDO0FBQUEsRUFDbEM7QUFDQSxTQUFPLFdBQVc7QUFDcEI7QUFRTyxTQUFTLFlBQVksTUFBcUI7QUFDL0MsU0FBTyxLQUFLLEtBQUssV0FBVyxRQUFRO0FBQ3RDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/Blob.d.cts

@@ -3,29 +3,29 @@
  * Contains utility functions for Blob objects.
  */
 /**
- * Converts a Blob object to an ArrayBuffer.
+ * Converts a {@link Blob} object to an {@link ArrayBuffer}.
  *
  * @param blob - The Blob object to convert.
- * @returns A promise that resolves to an ArrayBuffer.
+ * @returns A {@link Promise} that resolves to an {@link ArrayBuffer}.
  */
 export declare function blobToArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
 /**
- * Converts a Blob object to a data URL.
+ * Converts a {@link Blob} object to a data URL.
  *
  * @param blob - The Blob object to convert.
- * @returns A promise that resolves to a data URL.
+ * @returns A {@link Promise} that resolves to a data URL.
  */
 export declare function blobToDataUrl(blob: Blob): Promise<string>;
 /**
- * Converts a Blob object to a JPEG ArrayBuffer with the specified quality.
+ * Converts a {@link Blob} object to a JPEG ArrayBuffer with the specified quality.
  *
  * @param blob - The Blob object to convert.
  * @param jpegQuality - The quality of the JPEG image (0 to 1).
- * @returns A promise that resolves to an ArrayBuffer.
+ * @returns A {@link Promise} that resolves to an {@link ArrayBuffer}.
  */
 export declare function blobToJpegArrayBuffer(blob: Blob, jpegQuality: number): Promise<ArrayBuffer>;
 /**
- * Converts a base64 encoded string to an ArrayBuffer.
+ * Converts a base64 encoded string to an {@link ArrayBuffer}.
  *
  * @param dataUrl - The data URL to convert.
  * @returns The decoded ArrayBuffer.

package/dist/lib/cjs/Error.cjs

@@ -34,13 +34,13 @@ __export(Error_exports, {
   throwExpression: () => throwExpression
 });
 module.exports = __toCommonJS(Error_exports);
-var import_eventemitter3 = require('eventemitter3');
+var import_AsyncEvents = require('./AsyncEvents.cjs');
 const ASYNC_ERROR_EVENT = "asyncError";
 const ASYNC_ERROR_WRAPPER_MESSAGE = "An unhandled error occurred executing async operation";
-const asyncErrorEventEmitter = new import_eventemitter3.EventEmitter();
+const asyncErrorEventEmitter = new import_AsyncEvents.AsyncEvents();
 asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);
 function emitAsyncErrorEvent(asyncError) {
-  asyncErrorEventEmitter.emit(ASYNC_ERROR_EVENT, asyncError);
+  asyncErrorEventEmitter.trigger(ASYNC_ERROR_EVENT, asyncError);
 }
 function errorToString(error) {
   return parseErrorEntries(error).map((entry) => "  ".repeat(entry.level) + entry.message).join("\n");
@@ -63,8 +63,10 @@ function printError(error, console) {
   }
 }
 function registerAsyncErrorEventHandler(handler) {
-  asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
-  return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);
+  const eventRef = asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);
+  return () => {
+    asyncErrorEventEmitter.offref(eventRef);
+  };
 }
 function throwExpression(error) {
   throw error;
@@ -111,4 +113,4 @@ ${restStack}` });
   registerAsyncErrorEventHandler,
   throwExpression
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/Error.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Error\n * Contains utility functions for error handling.\n */\n\nimport { EventEmitter } from 'eventemitter3';\n\nconst ASYNC_ERROR_EVENT = 'asyncError';\n\n/**\n * The message of the error wrapper that is used to wrap an actual error that occurred during an async operation.\n */\nexport const ASYNC_ERROR_WRAPPER_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst asyncErrorEventEmitter = new EventEmitter();\nasyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);\n\ninterface ErrorEntry {\n  level: number;\n  message: string;\n  shouldClearAnsiSequence?: boolean;\n}\n\n/**\n * Emits an asynchronous error event.\n *\n * @param asyncError - The error to emit as an asynchronous error event.\n */\nexport function emitAsyncErrorEvent(asyncError: unknown): void {\n  asyncErrorEventEmitter.emit(ASYNC_ERROR_EVENT, asyncError);\n}\n\n/**\n * Converts an error to a string representation, including nested causes with indentation.\n *\n * @param error - The error to convert to a string.\n * @returns The string representation of the error.\n */\nexport function errorToString(error: unknown): string {\n  return parseErrorEntries(error).map((entry) => '  '.repeat(entry.level) + entry.message).join('\\n');\n}\n\n/**\n * Gets the current stack trace as a string, excluding the current function call.\n *\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A string representation of the current stack trace, excluding the current function call.\n */\nexport function getStackTrace(framesToSkip = 0): string {\n  // Skipping Error prefix and `getStackTrace` function call\n  const ADDITIONAL_FRAMES_TO_SKIP = 2;\n  const stack = new Error().stack ?? '';\n  const lines = stack.split('\\n');\n  return lines.slice(framesToSkip + ADDITIONAL_FRAMES_TO_SKIP).join('\\n');\n}\n\n/**\n * Prints an error to the console, including nested causes and optional ANSI sequence clearing.\n *\n * @param error - The error to print.\n * @param console - The console to print to (default: `globalThis.console`).\n */\nexport function printError(error: unknown, console?: Console): void {\n  console ??= globalThis.console;\n  const entries = parseErrorEntries(error);\n\n  for (const entry of entries) {\n    if (entry.shouldClearAnsiSequence) {\n      console.error(`\\x1b[0m${entry.message}\\x1b[0m`);\n    } else {\n      console.error(entry.message);\n    }\n  }\n}\n\n/**\n * Registers an event handler for asynchronous errors.\n *\n * @param handler - The handler function to be called when an asynchronous error event occurs.\n * @returns A function to unregister the handler.\n */\nexport function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void {\n  asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);\n  return () => asyncErrorEventEmitter.off(ASYNC_ERROR_EVENT, handler);\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @returns A never-returning function.\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\n/**\n * Handles asynchronous errors by printing them.\n *\n * @param asyncError - The asynchronous error to handle.\n */\nfunction handleAsyncError(asyncError: unknown): void {\n  printError(asyncError);\n}\n\n/**\n * Parses an error into an array of ErrorEntry objects, including nested causes.\n *\n * @param error - The error to parse.\n * @param level - The current indentation level for nested causes.\n * @param entries - The array of ErrorEntry objects to populate.\n * @returns An array of ErrorEntry objects representing the error and its causes.\n */\nfunction parseErrorEntries(error: unknown, level = 0, entries: ErrorEntry[] = []): ErrorEntry[] {\n  if (error === undefined) {\n    return entries;\n  }\n\n  if (!(error instanceof Error)) {\n    let str: string;\n\n    if (error === null) {\n      str = '(null)';\n    } else if (typeof error === 'string') {\n      str = error;\n    } else {\n      str = JSON.stringify(error) ?? 'undefined';\n    }\n\n    entries.push({ level, message: str });\n    return entries;\n  }\n\n  const title = `${error.name}: ${error.message}`;\n  entries.push({ level, message: title, shouldClearAnsiSequence: true });\n\n  if (error.stack) {\n    const restStack = error.stack.startsWith(title) ? error.stack.slice(title.length + 1) : error.stack;\n    entries.push({ level, message: `Error stack:\\n${restStack}` });\n  }\n\n  if (error.cause !== undefined) {\n    entries.push({ level, message: 'Caused by:' });\n    parseErrorEntries(error.cause, level + 1, entries);\n  }\n\n  return entries;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,2BAA6B;AAE7B,MAAM,oBAAoB;AAKnB,MAAM,8BAA8B;AAE3C,MAAM,yBAAyB,IAAI,kCAAa;AAChD,uBAAuB,GAAG,mBAAmB,gBAAgB;AAatD,SAAS,oBAAoB,YAA2B;AAC7D,yBAAuB,KAAK,mBAAmB,UAAU;AAC3D;AAQO,SAAS,cAAc,OAAwB;AACpD,SAAO,kBAAkB,KAAK,EAAE,IAAI,CAAC,UAAU,KAAK,OAAO,MAAM,KAAK,IAAI,MAAM,OAAO,EAAE,KAAK,IAAI;AACpG;AAQO,SAAS,cAAc,eAAe,GAAW;AAEtD,QAAM,4BAA4B;AAClC,QAAM,QAAQ,IAAI,MAAM,EAAE,SAAS;AACnC,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,SAAO,MAAM,MAAM,eAAe,yBAAyB,EAAE,KAAK,IAAI;AACxE;AAQO,SAAS,WAAW,OAAgB,SAAyB;AAClE,cAAY,WAAW;AACvB,QAAM,UAAU,kBAAkB,KAAK;AAEvC,aAAW,SAAS,SAAS;AAC3B,QAAI,MAAM,yBAAyB;AACjC,cAAQ,MAAM,UAAU,MAAM,OAAO,SAAS;AAAA,IAChD,OAAO;AACL,cAAQ,MAAM,MAAM,OAAO;AAAA,IAC7B;AAAA,EACF;AACF;AAQO,SAAS,+BAA+B,SAAoD;AACjG,yBAAuB,GAAG,mBAAmB,OAAO;AACpD,SAAO,MAAM,uBAAuB,IAAI,mBAAmB,OAAO;AACpE;AAQO,SAAS,gBAAgB,OAAuB;AACrD,QAAM;AACR;AAOA,SAAS,iBAAiB,YAA2B;AACnD,aAAW,UAAU;AACvB;AAUA,SAAS,kBAAkB,OAAgB,QAAQ,GAAG,UAAwB,CAAC,GAAiB;AAC9F,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,QAAI;AAEJ,QAAI,UAAU,MAAM;AAClB,YAAM;AAAA,IACR,WAAW,OAAO,UAAU,UAAU;AACpC,YAAM;AAAA,IACR,OAAO;AACL,YAAM,KAAK,UAAU,KAAK,KAAK;AAAA,IACjC;AAEA,YAAQ,KAAK,EAAE,OAAO,SAAS,IAAI,CAAC;AACpC,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO;AAC7C,UAAQ,KAAK,EAAE,OAAO,SAAS,OAAO,yBAAyB,KAAK,CAAC;AAErE,MAAI,MAAM,OAAO;AACf,UAAM,YAAY,MAAM,MAAM,WAAW,KAAK,IAAI,MAAM,MAAM,MAAM,MAAM,SAAS,CAAC,IAAI,MAAM;AAC9F,YAAQ,KAAK,EAAE,OAAO,SAAS;AAAA,EAAiB,SAAS,GAAG,CAAC;AAAA,EAC/D;AAEA,MAAI,MAAM,UAAU,QAAW;AAC7B,YAAQ,KAAK,EAAE,OAAO,SAAS,aAAa,CAAC;AAC7C,sBAAkB,MAAM,OAAO,QAAQ,GAAG,OAAO;AAAA,EACnD;AAEA,SAAO;AACT;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/Error.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation Error\n * Contains utility functions for error handling.\n */\n\nimport { AsyncEvents } from './AsyncEvents.ts';\n\nconst ASYNC_ERROR_EVENT = 'asyncError';\n\n/**\n * The message of the error wrapper that is used to wrap an actual error that occurred during an async operation.\n */\nexport const ASYNC_ERROR_WRAPPER_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst asyncErrorEventEmitter = new AsyncEvents();\nasyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handleAsyncError);\n\ninterface ErrorEntry {\n  level: number;\n  message: string;\n  shouldClearAnsiSequence?: boolean;\n}\n\n/**\n * Emits an asynchronous error event.\n *\n * @param asyncError - The error to emit as an asynchronous error event.\n */\nexport function emitAsyncErrorEvent(asyncError: unknown): void {\n  asyncErrorEventEmitter.trigger(ASYNC_ERROR_EVENT, asyncError);\n}\n\n/**\n * Converts an error to a string representation, including nested causes with indentation.\n *\n * @param error - The error to convert to a string.\n * @returns The string representation of the error.\n */\nexport function errorToString(error: unknown): string {\n  return parseErrorEntries(error).map((entry) => '  '.repeat(entry.level) + entry.message).join('\\n');\n}\n\n/**\n * Gets the current stack trace as a string, excluding the current function call.\n *\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A string representation of the current stack trace, excluding the current function call.\n */\nexport function getStackTrace(framesToSkip = 0): string {\n  // Skipping Error prefix and `getStackTrace` function call\n  const ADDITIONAL_FRAMES_TO_SKIP = 2;\n  const stack = new Error().stack ?? '';\n  const lines = stack.split('\\n');\n  return lines.slice(framesToSkip + ADDITIONAL_FRAMES_TO_SKIP).join('\\n');\n}\n\n/**\n * Prints an error to the console, including nested causes and optional ANSI sequence clearing.\n *\n * @param error - The error to print.\n * @param console - The console to print to (default: `globalThis.console`).\n */\nexport function printError(error: unknown, console?: Console): void {\n  console ??= globalThis.console;\n  const entries = parseErrorEntries(error);\n\n  for (const entry of entries) {\n    if (entry.shouldClearAnsiSequence) {\n      console.error(`\\x1b[0m${entry.message}\\x1b[0m`);\n    } else {\n      console.error(entry.message);\n    }\n  }\n}\n\n/**\n * Registers an event handler for asynchronous errors.\n *\n * @param handler - The handler function to be called when an asynchronous error event occurs.\n * @returns A function to unregister the handler.\n */\nexport function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void {\n  const eventRef = asyncErrorEventEmitter.on(ASYNC_ERROR_EVENT, handler);\n  return () => {\n    asyncErrorEventEmitter.offref(eventRef);\n  };\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @returns A never-returning function.\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\n/**\n * Handles asynchronous errors by printing them.\n *\n * @param asyncError - The asynchronous error to handle.\n */\nfunction handleAsyncError(asyncError: unknown): void {\n  printError(asyncError);\n}\n\n/**\n * Parses an error into an array of ErrorEntry objects, including nested causes.\n *\n * @param error - The error to parse.\n * @param level - The current indentation level for nested causes.\n * @param entries - The array of ErrorEntry objects to populate.\n * @returns An array of ErrorEntry objects representing the error and its causes.\n */\nfunction parseErrorEntries(error: unknown, level = 0, entries: ErrorEntry[] = []): ErrorEntry[] {\n  if (error === undefined) {\n    return entries;\n  }\n\n  if (!(error instanceof Error)) {\n    let str: string;\n\n    if (error === null) {\n      str = '(null)';\n    } else if (typeof error === 'string') {\n      str = error;\n    } else {\n      str = JSON.stringify(error) ?? 'undefined';\n    }\n\n    entries.push({ level, message: str });\n    return entries;\n  }\n\n  const title = `${error.name}: ${error.message}`;\n  entries.push({ level, message: title, shouldClearAnsiSequence: true });\n\n  if (error.stack) {\n    const restStack = error.stack.startsWith(title) ? error.stack.slice(title.length + 1) : error.stack;\n    entries.push({ level, message: `Error stack:\\n${restStack}` });\n  }\n\n  if (error.cause !== undefined) {\n    entries.push({ level, message: 'Caused by:' });\n    parseErrorEntries(error.cause, level + 1, entries);\n  }\n\n  return entries;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,yBAA4B;AAE5B,MAAM,oBAAoB;AAKnB,MAAM,8BAA8B;AAE3C,MAAM,yBAAyB,IAAI,+BAAY;AAC/C,uBAAuB,GAAG,mBAAmB,gBAAgB;AAatD,SAAS,oBAAoB,YAA2B;AAC7D,yBAAuB,QAAQ,mBAAmB,UAAU;AAC9D;AAQO,SAAS,cAAc,OAAwB;AACpD,SAAO,kBAAkB,KAAK,EAAE,IAAI,CAAC,UAAU,KAAK,OAAO,MAAM,KAAK,IAAI,MAAM,OAAO,EAAE,KAAK,IAAI;AACpG;AAQO,SAAS,cAAc,eAAe,GAAW;AAEtD,QAAM,4BAA4B;AAClC,QAAM,QAAQ,IAAI,MAAM,EAAE,SAAS;AACnC,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,SAAO,MAAM,MAAM,eAAe,yBAAyB,EAAE,KAAK,IAAI;AACxE;AAQO,SAAS,WAAW,OAAgB,SAAyB;AAClE,cAAY,WAAW;AACvB,QAAM,UAAU,kBAAkB,KAAK;AAEvC,aAAW,SAAS,SAAS;AAC3B,QAAI,MAAM,yBAAyB;AACjC,cAAQ,MAAM,UAAU,MAAM,OAAO,SAAS;AAAA,IAChD,OAAO;AACL,cAAQ,MAAM,MAAM,OAAO;AAAA,IAC7B;AAAA,EACF;AACF;AAQO,SAAS,+BAA+B,SAAoD;AACjG,QAAM,WAAW,uBAAuB,GAAG,mBAAmB,OAAO;AACrE,SAAO,MAAM;AACX,2BAAuB,OAAO,QAAQ;AAAA,EACxC;AACF;AAQO,SAAS,gBAAgB,OAAuB;AACrD,QAAM;AACR;AAOA,SAAS,iBAAiB,YAA2B;AACnD,aAAW,UAAU;AACvB;AAUA,SAAS,kBAAkB,OAAgB,QAAQ,GAAG,UAAwB,CAAC,GAAiB;AAC9F,MAAI,UAAU,QAAW;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,QAAI;AAEJ,QAAI,UAAU,MAAM;AAClB,YAAM;AAAA,IACR,WAAW,OAAO,UAAU,UAAU;AACpC,YAAM;AAAA,IACR,OAAO;AACL,YAAM,KAAK,UAAU,KAAK,KAAK;AAAA,IACjC;AAEA,YAAQ,KAAK,EAAE,OAAO,SAAS,IAAI,CAAC;AACpC,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO;AAC7C,UAAQ,KAAK,EAAE,OAAO,SAAS,OAAO,yBAAyB,KAAK,CAAC;AAErE,MAAI,MAAM,OAAO;AACf,UAAM,YAAY,MAAM,MAAM,WAAW,KAAK,IAAI,MAAM,MAAM,MAAM,MAAM,SAAS,CAAC,IAAI,MAAM;AAC9F,YAAQ,KAAK,EAAE,OAAO,SAAS;AAAA,EAAiB,SAAS,GAAG,CAAC;AAAA,EAC/D;AAEA,MAAI,MAAM,UAAU,QAAW;AAC7B,YAAQ,KAAK,EAAE,OAAO,SAAS,aAAa,CAAC;AAC7C,sBAAkB,MAAM,OAAO,QAAQ,GAAG,OAAO;AAAA,EACnD;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/cjs/HTMLElement.cjs

@@ -88,4 +88,4 @@ function getLoadableElements(el) {
   ensureLoaded,
   isLoaded
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/HTMLElement.d.cts

@@ -37,7 +37,7 @@ export declare function appendCodeBlock(el: DocumentFragment | HTMLElement, code
  * Ensures that the given element is loaded.
  *
  * @param el - The element to ensure is loaded.
- * @returns A promise that resolves when the element is loaded.
+ * @returns A {@link Promise} that resolves when the element is loaded.
  */
 export declare function ensureLoaded(el: Element): Promise<void>;
 /**