obsidian-dev-utils 80.1.0 → 82.0.0-beta.0

package/dist/lib/esm/debug.mjs

@@ -51,7 +51,12 @@ function getDebugger(namespace, framesToSkip = 0) {
   if (!debuggerEx) {
     debuggerEx = getSharedDebugLibInstance()(namespace);
     debuggerEx.log = (message, ...args) => {
-      logWithCaller(namespace, framesToSkip, message, ...args);
+      logWithCaller({
+        args,
+        framesToSkip,
+        message,
+        namespace
+      });
     };
     debuggersMap.set(key, debuggerEx);
   }
@@ -62,7 +67,13 @@ function getLibDebugger(namespace) {
   const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? "" : `${pluginId}:`;
   return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);
 }
-function printWithStackTrace(debuggerInstance, stackTrace, message, ...args) {
+function printWithStackTrace(params) {
+  const {
+    args,
+    debuggerInstance,
+    message,
+    stackTrace
+  } = params;
   if (!isInObsidian()) {
     debuggerInstance(message, ...args);
     return;
@@ -116,7 +127,13 @@ function getSharedDebugLibInstance() {
   }
   return getObsidianDevUtilsState("debug", debug).value;
 }
-function logWithCaller(namespace, framesToSkip, message, ...args) {
+function logWithCaller(params) {
+  const {
+    args,
+    framesToSkip,
+    message,
+    namespace
+  } = params;
   if (!getSharedDebugLibInstance().enabled(namespace)) {
     return;
   }
@@ -130,11 +147,11 @@ function logWithCaller(namespace, framesToSkip, message, ...args) {
   console.debug(message, ...args, "\n\n---\nLogger stack trace:\n", makeStackTraceError(stackLines.join("\n")));
 }
 function makeStackTraceError(stackTrace) {
-  return new CustomStackTraceError(
-    "Debug mode: intentional placeholder error. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md.",
-    stackTrace,
-    void 0
-  );
+  return new CustomStackTraceError({
+    cause: void 0,
+    message: "Debug mode: intentional placeholder error. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md.",
+    stackTrace
+  });
 }
 function setNamespaces(namespaces) {
   getSharedDebugLibInstance().enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));
@@ -150,4 +167,4 @@ export {
   printWithStackTrace,
   showInitialDebugMessage
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/debug.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for debugging.\n */\n\nimport type { Debugger } from 'debug';\n\nimport debug from 'debug';\n\nimport type { DebugController } from './debug-controller.ts';\n\nimport { CustomStackTraceError } from './error.ts';\nimport { LIBRARY_NAME } from './library.ts';\nimport { getObsidianDevUtilsState } from './obsidian-dev-utils-state.ts';\nimport { isInObsidian } from './obsidian/is-in-obsidian.ts';\nimport {\n  getPluginId,\n  NO_PLUGIN_ID_INITIALIZED\n} from './obsidian/plugin/plugin-id.ts';\nimport { ensureNonNullable } from './type-guards.ts';\n\nconst NAMESPACE_SEPARATOR = ',';\nconst NEGATED_NAMESPACE_PREFIX = '-';\n\n/**\n * Enables the debuggers for the `obsidian-dev-utils` library.\n */\nexport function enableLibraryDebuggers(): void {\n  enableNamespaces([LIBRARY_NAME, `${LIBRARY_NAME}:*`]);\n}\n\n/**\n * Returns a debug controller.\n *\n * @returns A debug controller.\n */\nexport function getDebugController(): DebugController {\n  return {\n    disable: disableNamespaces,\n    enable: enableNamespaces,\n    get: getNamespaces,\n    set: setNamespaces\n  };\n}\n\n/**\n * Returns a debugger instance with a log function that includes the caller's file name and line number.\n *\n * @param namespace - The namespace for the debugger instance.\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A debugger instance with a log function that includes the caller's file name and line number.\n */\nexport function getDebugger(namespace: string, framesToSkip = 0): Debugger {\n  const key = `${namespace}:${String(framesToSkip)}`;\n  const debuggersMap = getObsidianDevUtilsState('debuggers', new Map<string, Debugger>()).value;\n  let debuggerEx = debuggersMap.get(key);\n  if (!debuggerEx) {\n    debuggerEx = getSharedDebugLibInstance()(namespace);\n    debuggerEx.log = (message: string, ...args: unknown[]): void => {\n      logWithCaller(namespace, framesToSkip, message, ...args);\n    };\n\n    debuggersMap.set(key, debuggerEx);\n  }\n\n  return debuggerEx;\n}\n\n/**\n * Returns a debugger instance for the `obsidian-dev-utils` library.\n *\n * @param namespace - The namespace for the debugger instance.\n * @returns A debugger instance for the `obsidian-dev-utils` library.\n */\nexport function getLibDebugger(namespace: string): Debugger {\n  const pluginId = getPluginId();\n  const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? '' : `${pluginId}:`;\n  return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);\n}\n\n/**\n * Prints a message with a stack trace.\n *\n * @param debuggerInstance - The debugger instance.\n * @param stackTrace - The stack trace to print.\n * @param message - The message to print.\n * @param args - The arguments to print.\n */\nexport function printWithStackTrace(debuggerInstance: Debugger, stackTrace: string, message: string, ...args: unknown[]): void {\n  if (!isInObsidian()) {\n    debuggerInstance(message, ...args);\n    return;\n  }\n\n  debuggerInstance(message, ...args, '\\n\\n---\\nContext stack trace:\\n', makeStackTraceError(stackTrace));\n}\n\n/**\n * Shows an initial debug message.\n *\n * @param pluginId - The plugin ID.\n */\nexport function showInitialDebugMessage(pluginId: string): void {\n  const isEnabled = getSharedDebugLibInstance().enabled(pluginId);\n  const state = isEnabled ? 'enabled' : 'disabled';\n  const changeAction = isEnabled ? 'disable' : 'enable';\n  const namespaces = getNamespaces();\n  setNamespaces(pluginId);\n  getDebugger(pluginId)(\n    `Debug messages for plugin ${pluginId} are ${state}. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md how to ${changeAction} them.`\n  );\n  setNamespaces(namespaces);\n}\n\nfunction disableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      continue;\n    }\n    const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n    if (set.has(namespace)) {\n      set.delete(namespace);\n    }\n    set.add(negatedNamespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction enableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (!namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n      if (set.has(negatedNamespace)) {\n        set.delete(negatedNamespace);\n      }\n    }\n    set.add(namespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction getNamespaces(): string[] {\n  return toArray(getSharedDebugLibInstance().load() ?? '');\n}\n\nfunction getSharedDebugLibInstance(): typeof debug {\n  if (!isInObsidian()) {\n    return debug;\n  }\n  return getObsidianDevUtilsState('debug', debug).value;\n}\n\nfunction logWithCaller(namespace: string, framesToSkip: number, message: string, ...args: unknown[]): void {\n  if (!getSharedDebugLibInstance().enabled(namespace)) {\n    return;\n  }\n\n  if (!isInObsidian()) {\n    // eslint-disable-next-line no-console -- Valid usage.\n    console.debug(message, ...args);\n    return;\n  }\n\n  /**\n   * A caller line index is 4 because the call stack is as follows:\n   *\n   * 0: Error\n   * 1:     at logWithCaller (?:?:?)\n   * 2:     at debugInstance.log (?:?:?)\n   * 3:     at debug (?:?:?)\n   * 4:     at functionName (path/to/caller.js:?:?)\n   */\n  const CALLER_LINE_INDEX = 4;\n\n  const stackLines = ensureNonNullable(new Error().stack).split('\\n');\n  stackLines.splice(0, CALLER_LINE_INDEX + framesToSkip);\n\n  // eslint-disable-next-line no-console -- Valid usage.\n  console.debug(message, ...args, '\\n\\n---\\nLogger stack trace:\\n', makeStackTraceError(stackLines.join('\\n')));\n}\n\nfunction makeStackTraceError(stackTrace: string): CustomStackTraceError {\n  return new CustomStackTraceError(\n    'Debug mode: intentional placeholder error. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md.',\n    stackTrace,\n    undefined\n  );\n}\n\n/**\n * Sets the namespaces to enable.\n *\n * @param namespaces - The namespaces to enable.\n */\nfunction setNamespaces(namespaces: string | string[]): void {\n  getSharedDebugLibInstance().enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));\n}\n\nfunction toArray(namespaces: string | string[]): string[] {\n  return typeof namespaces === 'string' ? namespaces.split(NAMESPACE_SEPARATOR).filter(Boolean) : namespaces.flatMap(toArray);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/debug.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for debugging.\n */\n\nimport type { Debugger } from 'debug';\n\nimport debug from 'debug';\n\nimport type { DebugController } from './debug-controller.ts';\n\nimport { CustomStackTraceError } from './error.ts';\nimport { LIBRARY_NAME } from './library.ts';\nimport { getObsidianDevUtilsState } from './obsidian-dev-utils-state.ts';\nimport { isInObsidian } from './obsidian/is-in-obsidian.ts';\nimport {\n  getPluginId,\n  NO_PLUGIN_ID_INITIALIZED\n} from './obsidian/plugin/plugin-id.ts';\nimport { ensureNonNullable } from './type-guards.ts';\n\nconst NAMESPACE_SEPARATOR = ',';\nconst NEGATED_NAMESPACE_PREFIX = '-';\n\n/**\n * Parameters for {@link printWithStackTrace}.\n */\nexport interface PrintWithStackTraceParams {\n  /**\n   * The arguments to print.\n   */\n  readonly args: unknown[];\n\n  /**\n   * The debugger instance.\n   */\n  readonly debuggerInstance: Debugger;\n\n  /**\n   * The message to print.\n   */\n  readonly message: string;\n\n  /**\n   * The stack trace to print.\n   */\n  readonly stackTrace: string;\n}\n\n/**\n * Parameters for {@link logWithCaller}.\n */\ninterface LogWithCallerParams {\n  /**\n   * The arguments to print.\n   */\n  readonly args: unknown[];\n\n  /**\n   * The number of frames to skip in the stack trace.\n   */\n  readonly framesToSkip: number;\n\n  /**\n   * The message to print.\n   */\n  readonly message: string;\n\n  /**\n   * The namespace for the debugger instance.\n   */\n  readonly namespace: string;\n}\n\n/**\n * Enables the debuggers for the `obsidian-dev-utils` library.\n */\nexport function enableLibraryDebuggers(): void {\n  enableNamespaces([LIBRARY_NAME, `${LIBRARY_NAME}:*`]);\n}\n\n/**\n * Returns a debug controller.\n *\n * @returns A debug controller.\n */\nexport function getDebugController(): DebugController {\n  return {\n    disable: disableNamespaces,\n    enable: enableNamespaces,\n    get: getNamespaces,\n    set: setNamespaces\n  };\n}\n\n/**\n * Returns a debugger instance with a log function that includes the caller's file name and line number.\n *\n * @param namespace - The namespace for the debugger instance.\n * @param framesToSkip - The number of frames to skip in the stack trace.\n * @returns A debugger instance with a log function that includes the caller's file name and line number.\n */\nexport function getDebugger(namespace: string, framesToSkip = 0): Debugger {\n  const key = `${namespace}:${String(framesToSkip)}`;\n  const debuggersMap = getObsidianDevUtilsState('debuggers', new Map<string, Debugger>()).value;\n  let debuggerEx = debuggersMap.get(key);\n  if (!debuggerEx) {\n    debuggerEx = getSharedDebugLibInstance()(namespace);\n    debuggerEx.log = (message: string, ...args: unknown[]): void => {\n      logWithCaller({\n        args,\n        framesToSkip,\n        message,\n        namespace\n      });\n    };\n\n    debuggersMap.set(key, debuggerEx);\n  }\n\n  return debuggerEx;\n}\n\n/**\n * Returns a debugger instance for the `obsidian-dev-utils` library.\n *\n * @param namespace - The namespace for the debugger instance.\n * @returns A debugger instance for the `obsidian-dev-utils` library.\n */\nexport function getLibDebugger(namespace: string): Debugger {\n  const pluginId = getPluginId();\n  const prefix = pluginId === NO_PLUGIN_ID_INITIALIZED ? '' : `${pluginId}:`;\n  return getDebugger(`${prefix}${LIBRARY_NAME}:${namespace}`);\n}\n\n/**\n * Prints a message with a stack trace.\n *\n * @param params - The parameters for printing the message.\n */\nexport function printWithStackTrace(params: PrintWithStackTraceParams): void {\n  const {\n    args,\n    debuggerInstance,\n    message,\n    stackTrace\n  } = params;\n  if (!isInObsidian()) {\n    debuggerInstance(message, ...args);\n    return;\n  }\n\n  debuggerInstance(message, ...args, '\\n\\n---\\nContext stack trace:\\n', makeStackTraceError(stackTrace));\n}\n\n/**\n * Shows an initial debug message.\n *\n * @param pluginId - The plugin ID.\n */\nexport function showInitialDebugMessage(pluginId: string): void {\n  const isEnabled = getSharedDebugLibInstance().enabled(pluginId);\n  const state = isEnabled ? 'enabled' : 'disabled';\n  const changeAction = isEnabled ? 'disable' : 'enable';\n  const namespaces = getNamespaces();\n  setNamespaces(pluginId);\n  getDebugger(pluginId)(\n    `Debug messages for plugin ${pluginId} are ${state}. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md how to ${changeAction} them.`\n  );\n  setNamespaces(namespaces);\n}\n\nfunction disableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      continue;\n    }\n    const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n    if (set.has(namespace)) {\n      set.delete(namespace);\n    }\n    set.add(negatedNamespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction enableNamespaces(namespaces: string | string[]): void {\n  const set = new Set(getNamespaces());\n  for (const namespace of toArray(namespaces)) {\n    if (!namespace.startsWith(NEGATED_NAMESPACE_PREFIX)) {\n      const negatedNamespace = NEGATED_NAMESPACE_PREFIX + namespace;\n      if (set.has(negatedNamespace)) {\n        set.delete(negatedNamespace);\n      }\n    }\n    set.add(namespace);\n  }\n  setNamespaces(Array.from(set));\n}\n\nfunction getNamespaces(): string[] {\n  return toArray(getSharedDebugLibInstance().load() ?? '');\n}\n\nfunction getSharedDebugLibInstance(): typeof debug {\n  if (!isInObsidian()) {\n    return debug;\n  }\n  return getObsidianDevUtilsState('debug', debug).value;\n}\n\nfunction logWithCaller(params: LogWithCallerParams): void {\n  const {\n    args,\n    framesToSkip,\n    message,\n    namespace\n  } = params;\n  if (!getSharedDebugLibInstance().enabled(namespace)) {\n    return;\n  }\n\n  if (!isInObsidian()) {\n    // eslint-disable-next-line no-console -- Valid usage.\n    console.debug(message, ...args);\n    return;\n  }\n\n  /**\n   * A caller line index is 4 because the call stack is as follows:\n   *\n   * 0: Error\n   * 1:     at logWithCaller (?:?:?)\n   * 2:     at debugInstance.log (?:?:?)\n   * 3:     at debug (?:?:?)\n   * 4:     at functionName (path/to/caller.js:?:?)\n   */\n  const CALLER_LINE_INDEX = 4;\n\n  const stackLines = ensureNonNullable(new Error().stack).split('\\n');\n  stackLines.splice(0, CALLER_LINE_INDEX + framesToSkip);\n\n  // eslint-disable-next-line no-console -- Valid usage.\n  console.debug(message, ...args, '\\n\\n---\\nLogger stack trace:\\n', makeStackTraceError(stackLines.join('\\n')));\n}\n\nfunction makeStackTraceError(stackTrace: string): CustomStackTraceError {\n  return new CustomStackTraceError({\n    cause: undefined,\n    message: 'Debug mode: intentional placeholder error. See https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md.',\n    stackTrace\n  });\n}\n\n/**\n * Sets the namespaces to enable.\n *\n * @param namespaces - The namespaces to enable.\n */\nfunction setNamespaces(namespaces: string | string[]): void {\n  getSharedDebugLibInstance().enable(toArray(namespaces).join(NAMESPACE_SEPARATOR));\n}\n\nfunction toArray(namespaces: string | string[]): string[] {\n  return typeof namespaces === 'string' ? namespaces.split(NAMESPACE_SEPARATOR).filter(Boolean) : namespaces.flatMap(toArray);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/disposable.d.mts

@@ -0,0 +1,124 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Disposable utilities for `using` / `await using` declarations.
+ */
+import type { Promisable } from 'type-fest';
+/**
+ * Determines how a {@link CallbackDisposable} or {@link AsyncCallbackDisposable} behaves when it is
+ * disposed more than once.
+ */
+export declare enum MultipleDisposeBehavior {
+    /**
+     * Invoke the callback on every dispose.
+     */
+    Invoke = 0,
+    /**
+     * Invoke the callback on the first dispose only; subsequent disposes are no-ops.
+     */
+    Ignore = 1,
+    /**
+     * Invoke the callback on the first dispose only; subsequent disposes throw.
+     */
+    Throw = 2
+}
+/**
+ * The parameters for constructing an {@link AsyncCallbackDisposable}.
+ */
+export interface AsyncCallbackDisposableConstructorParams {
+    /**
+     * The callback to execute when disposed.
+     */
+    readonly callback: AsyncDisposeCallback;
+    /**
+     * How the disposable behaves when disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Invoke}
+     */
+    readonly multipleDisposeBehavior?: MultipleDisposeBehavior;
+}
+/**
+ * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.
+ */
+export type AsyncDisposeCallback = (this: void) => Promisable<void>;
+/**
+ * The parameters for constructing a {@link CallbackDisposable}.
+ */
+export interface CallbackDisposableConstructorParams {
+    /**
+     * The callback to execute when disposed.
+     */
+    readonly callback: DisposeCallback;
+    /**
+     * How the disposable behaves when disposed more than once.
+     *
+     * @default {@link MultipleDisposeBehavior.Invoke}
+     */
+    readonly multipleDisposeBehavior?: MultipleDisposeBehavior;
+}
+/**
+ * A callback invoked when a {@link CallbackDisposable} is disposed.
+ */
+export type DisposeCallback = (this: void) => void;
+/**
+ * An async disposable that executes a callback when disposed via `await using` (or a manual
+ * `await disposable[Symbol.asyncDispose]()`).
+ */
+export declare class AsyncCallbackDisposable implements AsyncDisposable {
+    private readonly callback;
+    private isDisposed;
+    private readonly multipleDisposeBehavior;
+    /**
+     * Creates a new instance of {@link AsyncCallbackDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: AsyncCallbackDisposableConstructorParams);
+    /**
+     * Disposes the object by executing the callback.
+     *
+     * This method is called automatically when the object is used in an `await using` declaration. It
+     * can also be called manually. The behavior on a second and later dispose is controlled by
+     * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.
+     *
+     * @returns A {@link Promise} that resolves once the callback completes.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * A disposable that executes a callback when disposed.
+ */
+export declare class CallbackDisposable implements Disposable {
+    private readonly callback;
+    private isDisposed;
+    private readonly multipleDisposeBehavior;
+    /**
+     * Creates a new instance of {@link CallbackDisposable}.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: CallbackDisposableConstructorParams);
+    /**
+     * Disposes the object by executing the callback.
+     *
+     * This method is called automatically when the object is used in a `using` declaration. It can also
+     * be called manually. The behavior on a second and later dispose is controlled by
+     * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.
+     */
+    [Symbol.dispose](): void;
+}
+/**
+ * Type guard to check if an object implements the {@link AsyncDisposable} interface.
+ *
+ * @param obj - the object to check for the {@link AsyncDisposable} interface
+ * @returns Whether the object implements the {@link AsyncDisposable} interface
+ */
+export declare function isAsyncDisposable(obj: unknown): obj is AsyncDisposable;
+/**
+ * Type guard to check if an object implements the {@link Disposable} interface.
+ *
+ * @param obj - the object to check for the {@link Disposable} interface
+ * @returns Whether the object implements the {@link Disposable} interface
+ */
+export declare function isDisposable(obj: unknown): obj is Disposable;

package/dist/lib/esm/disposable.mjs

@@ -0,0 +1,122 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { assertNever } from "./type-guards.mjs";
+var MultipleDisposeBehavior = /* @__PURE__ */ ((MultipleDisposeBehavior2) => {
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Invoke"] = 0] = "Invoke";
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Ignore"] = 1] = "Ignore";
+  MultipleDisposeBehavior2[MultipleDisposeBehavior2["Throw"] = 2] = "Throw";
+  return MultipleDisposeBehavior2;
+})(MultipleDisposeBehavior || {});
+class AsyncCallbackDisposable {
+  callback;
+  isDisposed = false;
+  multipleDisposeBehavior;
+  /**
+   * Creates a new instance of {@link AsyncCallbackDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    this.callback = params.callback;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
+  }
+  /**
+   * Disposes the object by executing the callback.
+   *
+   * This method is called automatically when the object is used in an `await using` declaration. It
+   * can also be called manually. The behavior on a second and later dispose is controlled by
+   * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.
+   *
+   * @returns A {@link Promise} that resolves once the callback completes.
+   */
+  async [Symbol.asyncDispose]() {
+    if (this.isDisposed) {
+      switch (this.multipleDisposeBehavior) {
+        case 1 /* Ignore */:
+          return;
+        case 0 /* Invoke */:
+          break;
+        case 2 /* Throw */:
+          throw new Error("This AsyncCallbackDisposable has already been disposed.");
+        default:
+          assertNever(this.multipleDisposeBehavior);
+      }
+    }
+    this.isDisposed = true;
+    await this.callback();
+  }
+}
+class CallbackDisposable {
+  callback;
+  isDisposed = false;
+  multipleDisposeBehavior;
+  /**
+   * Creates a new instance of {@link CallbackDisposable}.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    this.callback = params.callback;
+    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? 0 /* Invoke */;
+  }
+  /**
+   * Disposes the object by executing the callback.
+   *
+   * This method is called automatically when the object is used in a `using` declaration. It can also
+   * be called manually. The behavior on a second and later dispose is controlled by
+   * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.
+   */
+  [Symbol.dispose]() {
+    if (this.isDisposed) {
+      switch (this.multipleDisposeBehavior) {
+        case 1 /* Ignore */:
+          return;
+        case 0 /* Invoke */:
+          break;
+        case 2 /* Throw */:
+          throw new Error("This CallbackDisposable has already been disposed.");
+        default:
+          assertNever(this.multipleDisposeBehavior);
+      }
+    }
+    this.isDisposed = true;
+    this.callback();
+  }
+}
+function isAsyncDisposable(obj) {
+  const asyncDisposable = obj;
+  return !!asyncDisposable[Symbol.asyncDispose];
+}
+function isDisposable(obj) {
+  const disposable = obj;
+  return !!disposable[Symbol.dispose];
+}
+export {
+  AsyncCallbackDisposable,
+  CallbackDisposable,
+  MultipleDisposeBehavior,
+  isAsyncDisposable,
+  isDisposable
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/disposable.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Disposable utilities for `using` / `await using` declarations.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { assertNever } from './type-guards.ts';\n\n/**\n * Determines how a {@link CallbackDisposable} or {@link AsyncCallbackDisposable} behaves when it is\n * disposed more than once.\n */\nexport enum MultipleDisposeBehavior {\n  /**\n   * Invoke the callback on every dispose.\n   */\n  Invoke,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes are no-ops.\n   */\n  Ignore,\n\n  /**\n   * Invoke the callback on the first dispose only; subsequent disposes throw.\n   */\n  Throw\n}\n\n/**\n * The parameters for constructing an {@link AsyncCallbackDisposable}.\n */\nexport interface AsyncCallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: AsyncDisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * A callback invoked when an {@link AsyncCallbackDisposable} is disposed.\n */\nexport type AsyncDisposeCallback = (this: void) => Promisable<void>;\n\n/**\n * The parameters for constructing a {@link CallbackDisposable}.\n */\nexport interface CallbackDisposableConstructorParams {\n  /**\n   * The callback to execute when disposed.\n   */\n  readonly callback: DisposeCallback;\n\n  /**\n   * How the disposable behaves when disposed more than once.\n   *\n   * @default {@link MultipleDisposeBehavior.Invoke}\n   */\n  readonly multipleDisposeBehavior?: MultipleDisposeBehavior;\n}\n\n/**\n * A callback invoked when a {@link CallbackDisposable} is disposed.\n */\nexport type DisposeCallback = (this: void) => void;\n\n/**\n * An async disposable that executes a callback when disposed via `await using` (or a manual\n * `await disposable[Symbol.asyncDispose]()`).\n */\nexport class AsyncCallbackDisposable implements AsyncDisposable {\n  private readonly callback: AsyncDisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link AsyncCallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: AsyncCallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in an `await using` declaration. It\n   * can also be called manually. The behavior on a second and later dispose is controlled by\n   * {@link AsyncCallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   *\n   * @returns A {@link Promise} that resolves once the callback completes.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This AsyncCallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    await this.callback();\n  }\n}\n\n/**\n * A disposable that executes a callback when disposed.\n */\nexport class CallbackDisposable implements Disposable {\n  private readonly callback: DisposeCallback;\n  private isDisposed = false;\n  private readonly multipleDisposeBehavior: MultipleDisposeBehavior;\n\n  /**\n   * Creates a new instance of {@link CallbackDisposable}.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: CallbackDisposableConstructorParams) {\n    this.callback = params.callback;\n    this.multipleDisposeBehavior = params.multipleDisposeBehavior ?? MultipleDisposeBehavior.Invoke;\n  }\n\n  /**\n   * Disposes the object by executing the callback.\n   *\n   * This method is called automatically when the object is used in a `using` declaration. It can also\n   * be called manually. The behavior on a second and later dispose is controlled by\n   * {@link CallbackDisposableConstructorParams.multipleDisposeBehavior}.\n   */\n  public [Symbol.dispose](): void {\n    if (this.isDisposed) {\n      switch (this.multipleDisposeBehavior) {\n        case MultipleDisposeBehavior.Ignore:\n          return;\n        case MultipleDisposeBehavior.Invoke:\n          break;\n        case MultipleDisposeBehavior.Throw:\n          throw new Error('This CallbackDisposable has already been disposed.');\n        default:\n          assertNever(this.multipleDisposeBehavior);\n      }\n    }\n\n    this.isDisposed = true;\n    this.callback();\n  }\n}\n\n/**\n * Type guard to check if an object implements the {@link AsyncDisposable} interface.\n *\n * @param obj - the object to check for the {@link AsyncDisposable} interface\n * @returns Whether the object implements the {@link AsyncDisposable} interface\n */\nexport function isAsyncDisposable(obj: unknown): obj is AsyncDisposable {\n  const asyncDisposable = obj as Partial<AsyncDisposable>;\n  return !!asyncDisposable[Symbol.asyncDispose];\n}\n\n/**\n * Type guard to check if an object implements the {@link Disposable} interface.\n *\n * @param obj - the object to check for the {@link Disposable} interface\n * @returns Whether the object implements the {@link Disposable} interface\n */\nexport function isDisposable(obj: unknown): obj is Disposable {\n  const disposable = obj as Partial<Disposable>;\n  return !!disposable[Symbol.dispose];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,mBAAmB;AAMrB,IAAK,0BAAL,kBAAKA,6BAAL;AAIL,EAAAA,kDAAA;AAKA,EAAAA,kDAAA;AAKA,EAAAA,kDAAA;AAdU,SAAAA;AAAA,GAAA;AAiEL,MAAM,wBAAmD;AAAA,EAC7C;AAAA,EACT,aAAa;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAkD;AACnE,SAAK,WAAW,OAAO;AACvB,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAc,OAAO,YAAY,IAAmB;AAClD,QAAI,KAAK,YAAY;AACnB,cAAQ,KAAK,yBAAyB;AAAA,QACpC,KAAK;AACH;AAAA,QACF,KAAK;AACH;AAAA,QACF,KAAK;AACH,gBAAM,IAAI,MAAM,yDAAyD;AAAA,QAC3E;AACE,sBAAY,KAAK,uBAAuB;AAAA,MAC5C;AAAA,IACF;AAEA,SAAK,aAAa;AAClB,UAAM,KAAK,SAAS;AAAA,EACtB;AACF;AAKO,MAAM,mBAAyC;AAAA,EACnC;AAAA,EACT,aAAa;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA6C;AAC9D,SAAK,WAAW,OAAO;AACvB,SAAK,0BAA0B,OAAO,2BAA2B;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,CAAQ,OAAO,OAAO,IAAU;AAC9B,QAAI,KAAK,YAAY;AACnB,cAAQ,KAAK,yBAAyB;AAAA,QACpC,KAAK;AACH;AAAA,QACF,KAAK;AACH;AAAA,QACF,KAAK;AACH,gBAAM,IAAI,MAAM,oDAAoD;AAAA,QACtE;AACE,sBAAY,KAAK,uBAAuB;AAAA,MAC5C;AAAA,IACF;AAEA,SAAK,aAAa;AAClB,SAAK,SAAS;AAAA,EAChB;AACF;AAQO,SAAS,kBAAkB,KAAsC;AACtE,QAAM,kBAAkB;AACxB,SAAO,CAAC,CAAC,gBAAgB,OAAO,YAAY;AAC9C;AAQO,SAAS,aAAa,KAAiC;AAC5D,QAAM,aAAa;AACnB,SAAO,CAAC,CAAC,WAAW,OAAO,OAAO;AACpC;",
  "names": ["MultipleDisposeBehavior"]
}


package/dist/lib/esm/error.d.mts

@@ -8,6 +8,23 @@
  * A message of the AsyncWrapperError.
  */
 export declare const ASYNC_WRAPPER_ERROR_MESSAGE = "An unhandled error occurred executing async operation";
+/**
+ * Parameters for the {@link CustomStackTraceError} constructor.
+ */
+export interface CustomStackTraceErrorConstructorParams {
+    /**
+     * The cause of the error.
+     */
+    readonly cause: unknown;
+    /**
+     * The message of the error.
+     */
+    readonly message: string;
+    /**
+     * The stack trace of the error.
+     */
+    readonly stackTrace: string;
+}
 /**
  * An error that wraps an error with a custom stack trace.
  */
@@ -15,11 +32,9 @@ export declare class CustomStackTraceError extends Error {
     /**
      * Creates a new CustomStackTraceError.
      *
-     * @param message - The message of the error.
-     * @param stackTrace - The stack trace of the error.
-     * @param cause - The cause of the error.
+     * @param params - The parameters for the error.
      */
-    constructor(message: string, stackTrace: string, cause: unknown);
+    constructor(params: CustomStackTraceErrorConstructorParams);
 }
 /**
  * An error that wraps a non-`Error` value that was thrown, preserving the original value in `cause`.
@@ -59,7 +74,8 @@ export declare class SilentError extends Error {
  */
 export declare function emitAsyncErrorEvent(asyncError: unknown): void;
 /**
- * Converts an error to a string representation, including nested causes with indentation.
+ * Converts an error to a string representation, including nested causes and the aggregated errors of
+ * an `AggregateError`, with indentation.
  *
  * @param error - The error to convert to a string.
  * @returns The string representation of the error.
@@ -83,9 +99,9 @@ export declare function printError(error: unknown, console?: Console): void;
  * Registers an event handler for asynchronous errors.
  *
  * @param handler - The handler function to be called when an asynchronous error event occurs.
- * @returns A function to unregister the handler.
+ * @returns A {@link Disposable} that unregisters the handler when disposed, for use with `using`.
  */
-export declare function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): () => void;
+export declare function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): Disposable;
 /**
  * Throws an error with the specified message.
  *

package/dist/lib/esm/error.mjs

@@ -22,6 +22,7 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { AsyncEvents } from "./async-events.mjs";
+import { CallbackDisposable } from "./disposable.mjs";
 import { ensureNonNullable } from "./type-guards.mjs";
 const errorAsyncEvents = new AsyncEvents();
 errorAsyncEvents.on("asyncError", handleAsyncError);
@@ -31,11 +32,10 @@ class CustomStackTraceError extends Error {
   /**
    * Creates a new CustomStackTraceError.
    *
-   * @param message - The message of the error.
-   * @param stackTrace - The stack trace of the error.
-   * @param cause - The cause of the error.
+   * @param params - The parameters for the error.
    */
-  constructor(message, stackTrace, cause) {
+  constructor(params) {
+    const { cause, message, stackTrace } = params;
     super(message, { cause });
     this.name = "CustomStackTraceError";
     Error.captureStackTrace?.(this, CustomStackTraceError);
@@ -102,16 +102,12 @@ function errorToString(error) {
   }
   let message = error.stack ?? `${error.name}: ${error.message}`;
   if (error.cause !== void 0) {
-    const causeStrLines = errorToString(error.cause).split("\n");
-    message += `
-${generateStackTraceLine("Caused by:")}`;
-    for (const line of causeStrLines) {
-      if (!line.trim()) {
-        continue;
-      }
-      message += line.startsWith(STACK_TRACE_PREFIX) ? `
-${line}` : `
-${generateStackTraceLine(line)}`;
+    message = appendNestedError(message, error.cause, "Caused by:");
+  }
+  if (error instanceof AggregateError) {
+    const aggregatedErrors = error.errors;
+    for (const [index, aggregatedError] of aggregatedErrors.entries()) {
+      message = appendNestedError(message, aggregatedError, `Aggregated error #${String(index + 1)}:`);
     }
   }
   return message;
@@ -128,13 +124,28 @@ function printError(error, console) {
 }
 function registerAsyncErrorEventHandler(handler) {
   const eventRef = errorAsyncEvents.on("asyncError", handler);
-  return () => {
-    errorAsyncEvents.offref(eventRef);
-  };
+  return new CallbackDisposable({
+    callback: () => {
+      errorAsyncEvents.offref(eventRef);
+    }
+  });
 }
 function throwExpression(error) {
   throw error;
 }
+function appendNestedError(message, nestedError, title) {
+  let result = `${message}
+${generateStackTraceLine(title)}`;
+  for (const line of errorToString(nestedError).split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    result += line.startsWith(STACK_TRACE_PREFIX) ? `
+${line}` : `
+${generateStackTraceLine(line)}`;
+  }
+  return result;
+}
 function generateStackTraceLine(title) {
   return `${STACK_TRACE_PREFIX} --- ${title} --- (0)`;
 }
@@ -153,4 +164,4 @@ export {
   registerAsyncErrorEventHandler,
   throwExpression
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/error.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for error handling.\n */\n\nimport { AsyncEvents } from './async-events.ts';\nimport { ensureNonNullable } from './type-guards.ts';\n\ninterface ErrorAsyncEventMap {\n  asyncError: [error: unknown];\n}\n\nconst errorAsyncEvents = new AsyncEvents<ErrorAsyncEventMap>();\nerrorAsyncEvents.on('asyncError', handleAsyncError);\n\n/**\n * A message of the AsyncWrapperError.\n */\nexport const ASYNC_WRAPPER_ERROR_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst STACK_TRACE_PREFIX = '    at';\n\n/**\n * An error that wraps an error with a custom stack trace.\n */\nexport class CustomStackTraceError extends Error {\n  /**\n   * Creates a new CustomStackTraceError.\n   *\n   * @param message - The message of the error.\n   * @param stackTrace - The stack trace of the error.\n   * @param cause - The cause of the error.\n   */\n  public constructor(message: string, stackTrace: string, cause: unknown) {\n    super(message, { cause });\n    this.name = 'CustomStackTraceError';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, CustomStackTraceError);\n\n    let rootCause = cause;\n    const parentCauses = new Set<CustomStackTraceError>();\n    while (rootCause instanceof CustomStackTraceError) {\n      if (parentCauses.has(rootCause)) {\n        throw new Error('Circular cause detected');\n      }\n      parentCauses.add(rootCause);\n      rootCause = rootCause.cause;\n    }\n\n    const originalStackLines = ensureNonNullable(this.stack).split('\\n');\n    const stackLines = stackTrace.split('\\n');\n    const ERROR_HEADER_REG_EXP = /^\\w*Error(?:: |$)/;\n    if (ERROR_HEADER_REG_EXP.test(ensureNonNullable(stackLines[0]))) {\n      stackLines.splice(0, 1);\n    }\n    originalStackLines.splice(1, originalStackLines.length - 1, ...stackLines);\n    this.stack = originalStackLines.join('\\n');\n  }\n}\n\n/**\n * An error that wraps a non-`Error` value that was thrown, preserving the original value in `cause`.\n */\nexport class ErrorWrapper extends Error {\n  /**\n   * Creates a new ErrorWrapper.\n   *\n   * @param thrownValue - The original non-`Error` value that was thrown.\n   */\n  public constructor(thrownValue: unknown) {\n    super(`A non-Error value was thrown: ${String(thrownValue)}`, { cause: thrownValue });\n    this.name = 'ErrorWrapper';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, ErrorWrapper);\n  }\n\n  /**\n   * Normalizes any thrown value to an `Error`.\n   *\n   * Returns the value unchanged if it is already an `Error`, otherwise wraps it in an {@link ErrorWrapper}.\n   *\n   * @param thrownValue - The thrown value to normalize.\n   * @returns An `Error` instance: the original value if it is already an `Error`, otherwise an {@link ErrorWrapper}.\n   */\n  public static create(thrownValue: unknown): Error {\n    return thrownValue instanceof Error ? thrownValue : new ErrorWrapper(thrownValue);\n  }\n}\n\n/**\n * An error that is not printed to the console.\n */\nexport class SilentError extends Error {\n  /**\n   * Creates a new SilentError.\n   *\n   * @param message - The message of the error.\n   */\n  public constructor(message: string) {\n    super(message);\n    this.name = 'SilentError';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, SilentError);\n  }\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  errorAsyncEvents.trigger('asyncError', 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  if (!(error instanceof Error)) {\n    return String(error);\n  }\n\n  let message = error.stack ?? `${error.name}: ${error.message}`;\n  if (error.cause !== undefined) {\n    const causeStrLines = errorToString(error.cause).split('\\n');\n    message += `\\n${generateStackTraceLine('Caused by:')}`;\n    for (const line of causeStrLines) {\n      if (!line.trim()) {\n        continue;\n      }\n      message += line.startsWith(STACK_TRACE_PREFIX)\n        ? `\\n${line}`\n        : `\\n${generateStackTraceLine(line)}`;\n    }\n  }\n  return message;\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 = ensureNonNullable(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  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.\n  console ??= globalThis.console;\n  console.error(errorToString(error));\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 = errorAsyncEvents.on('asyncError', handler);\n  return () => {\n    errorAsyncEvents.offref(eventRef);\n  };\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @throws\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\nfunction generateStackTraceLine(title: string): string {\n  return `${STACK_TRACE_PREFIX} --- ${title} --- (0)`;\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"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/error.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for error handling.\n */\n\nimport { AsyncEvents } from './async-events.ts';\nimport { CallbackDisposable } from './disposable.ts';\nimport { ensureNonNullable } from './type-guards.ts';\n\ninterface ErrorAsyncEventMap {\n  asyncError: [error: unknown];\n}\n\nconst errorAsyncEvents = new AsyncEvents<ErrorAsyncEventMap>();\nerrorAsyncEvents.on('asyncError', handleAsyncError);\n\n/**\n * A message of the AsyncWrapperError.\n */\nexport const ASYNC_WRAPPER_ERROR_MESSAGE = 'An unhandled error occurred executing async operation';\n\nconst STACK_TRACE_PREFIX = '    at';\n\n/**\n * Parameters for the {@link CustomStackTraceError} constructor.\n */\nexport interface CustomStackTraceErrorConstructorParams {\n  /**\n   * The cause of the error.\n   */\n  readonly cause: unknown;\n\n  /**\n   * The message of the error.\n   */\n  readonly message: string;\n\n  /**\n   * The stack trace of the error.\n   */\n  readonly stackTrace: string;\n}\n\n/**\n * An error that wraps an error with a custom stack trace.\n */\nexport class CustomStackTraceError extends Error {\n  /**\n   * Creates a new CustomStackTraceError.\n   *\n   * @param params - The parameters for the error.\n   */\n  public constructor(params: CustomStackTraceErrorConstructorParams) {\n    const { cause, message, stackTrace } = params;\n    super(message, { cause });\n    this.name = 'CustomStackTraceError';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, CustomStackTraceError);\n\n    let rootCause = cause;\n    const parentCauses = new Set<CustomStackTraceError>();\n    while (rootCause instanceof CustomStackTraceError) {\n      if (parentCauses.has(rootCause)) {\n        throw new Error('Circular cause detected');\n      }\n      parentCauses.add(rootCause);\n      rootCause = rootCause.cause;\n    }\n\n    const originalStackLines = ensureNonNullable(this.stack).split('\\n');\n    const stackLines = stackTrace.split('\\n');\n    const ERROR_HEADER_REG_EXP = /^\\w*Error(?:: |$)/;\n    if (ERROR_HEADER_REG_EXP.test(ensureNonNullable(stackLines[0]))) {\n      stackLines.splice(0, 1);\n    }\n    originalStackLines.splice(1, originalStackLines.length - 1, ...stackLines);\n    this.stack = originalStackLines.join('\\n');\n  }\n}\n\n/**\n * An error that wraps a non-`Error` value that was thrown, preserving the original value in `cause`.\n */\nexport class ErrorWrapper extends Error {\n  /**\n   * Creates a new ErrorWrapper.\n   *\n   * @param thrownValue - The original non-`Error` value that was thrown.\n   */\n  public constructor(thrownValue: unknown) {\n    super(`A non-Error value was thrown: ${String(thrownValue)}`, { cause: thrownValue });\n    this.name = 'ErrorWrapper';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, ErrorWrapper);\n  }\n\n  /**\n   * Normalizes any thrown value to an `Error`.\n   *\n   * Returns the value unchanged if it is already an `Error`, otherwise wraps it in an {@link ErrorWrapper}.\n   *\n   * @param thrownValue - The thrown value to normalize.\n   * @returns An `Error` instance: the original value if it is already an `Error`, otherwise an {@link ErrorWrapper}.\n   */\n  public static create(thrownValue: unknown): Error {\n    return thrownValue instanceof Error ? thrownValue : new ErrorWrapper(thrownValue);\n  }\n}\n\n/**\n * An error that is not printed to the console.\n */\nexport class SilentError extends Error {\n  /**\n   * Creates a new SilentError.\n   *\n   * @param message - The message of the error.\n   */\n  public constructor(message: string) {\n    super(message);\n    this.name = 'SilentError';\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `?.` is used to support iOS before 17.2.\n    Error.captureStackTrace?.(this, SilentError);\n  }\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  errorAsyncEvents.trigger('asyncError', asyncError);\n}\n\n/**\n * Converts an error to a string representation, including nested causes and the aggregated errors of\n * an `AggregateError`, 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  if (!(error instanceof Error)) {\n    return String(error);\n  }\n\n  let message = error.stack ?? `${error.name}: ${error.message}`;\n  if (error.cause !== undefined) {\n    message = appendNestedError(message, error.cause, 'Caused by:');\n  }\n  if (error instanceof AggregateError) {\n    const aggregatedErrors: readonly unknown[] = error.errors;\n    for (const [index, aggregatedError] of aggregatedErrors.entries()) {\n      message = appendNestedError(message, aggregatedError, `Aggregated error #${String(index + 1)}:`);\n    }\n  }\n  return message;\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 = ensureNonNullable(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  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.\n  console ??= globalThis.console;\n  console.error(errorToString(error));\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 {@link Disposable} that unregisters the handler when disposed, for use with `using`.\n */\nexport function registerAsyncErrorEventHandler(handler: (asyncError: unknown) => void): Disposable {\n  const eventRef = errorAsyncEvents.on('asyncError', handler);\n  return new CallbackDisposable({\n    callback: (): void => {\n      errorAsyncEvents.offref(eventRef);\n    }\n  });\n}\n\n/**\n * Throws an error with the specified message.\n *\n * @param error - The error to throw.\n * @throws\n */\nexport function throwExpression(error: unknown): never {\n  throw error;\n}\n\nfunction appendNestedError(message: string, nestedError: unknown, title: string): string {\n  let result = `${message}\\n${generateStackTraceLine(title)}`;\n  for (const line of errorToString(nestedError).split('\\n')) {\n    if (!line.trim()) {\n      continue;\n    }\n    result += line.startsWith(STACK_TRACE_PREFIX)\n      ? `\\n${line}`\n      : `\\n${generateStackTraceLine(line)}`;\n  }\n  return result;\n}\n\nfunction generateStackTraceLine(title: string): string {\n  return `${STACK_TRACE_PREFIX} --- ${title} --- (0)`;\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"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,mBAAmB;AAC5B,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAMlC,MAAM,mBAAmB,IAAI,YAAgC;AAC7D,iBAAiB,GAAG,cAAc,gBAAgB;AAK3C,MAAM,8BAA8B;AAE3C,MAAM,qBAAqB;AAyBpB,MAAM,8BAA8B,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMxC,YAAY,QAAgD;AACjE,UAAM,EAAE,OAAO,SAAS,WAAW,IAAI;AACvC,UAAM,SAAS,EAAE,MAAM,CAAC;AACxB,SAAK,OAAO;AAGZ,UAAM,oBAAoB,MAAM,qBAAqB;AAErD,QAAI,YAAY;AAChB,UAAM,eAAe,oBAAI,IAA2B;AACpD,WAAO,qBAAqB,uBAAuB;AACjD,UAAI,aAAa,IAAI,SAAS,GAAG;AAC/B,cAAM,IAAI,MAAM,yBAAyB;AAAA,MAC3C;AACA,mBAAa,IAAI,SAAS;AAC1B,kBAAY,UAAU;AAAA,IACxB;AAEA,UAAM,qBAAqB,kBAAkB,KAAK,KAAK,EAAE,MAAM,IAAI;AACnE,UAAM,aAAa,WAAW,MAAM,IAAI;AACxC,UAAM,uBAAuB;AAC7B,QAAI,qBAAqB,KAAK,kBAAkB,WAAW,CAAC,CAAC,CAAC,GAAG;AAC/D,iBAAW,OAAO,GAAG,CAAC;AAAA,IACxB;AACA,uBAAmB,OAAO,GAAG,mBAAmB,SAAS,GAAG,GAAG,UAAU;AACzE,SAAK,QAAQ,mBAAmB,KAAK,IAAI;AAAA,EAC3C;AACF;AAKO,MAAM,qBAAqB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM/B,YAAY,aAAsB;AACvC,UAAM,iCAAiC,OAAO,WAAW,CAAC,IAAI,EAAE,OAAO,YAAY,CAAC;AACpF,SAAK,OAAO;AAGZ,UAAM,oBAAoB,MAAM,YAAY;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,OAAc,OAAO,aAA6B;AAChD,WAAO,uBAAuB,QAAQ,cAAc,IAAI,aAAa,WAAW;AAAA,EAClF;AACF;AAKO,MAAM,oBAAoB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM9B,YAAY,SAAiB;AAClC,UAAM,OAAO;AACb,SAAK,OAAO;AAGZ,UAAM,oBAAoB,MAAM,WAAW;AAAA,EAC7C;AACF;AAOO,SAAS,oBAAoB,YAA2B;AAC7D,mBAAiB,QAAQ,cAAc,UAAU;AACnD;AASO,SAAS,cAAc,OAAwB;AACpD,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO,OAAO,KAAK;AAAA,EACrB;AAEA,MAAI,UAAU,MAAM,SAAS,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO;AAC5D,MAAI,MAAM,UAAU,QAAW;AAC7B,cAAU,kBAAkB,SAAS,MAAM,OAAO,YAAY;AAAA,EAChE;AACA,MAAI,iBAAiB,gBAAgB;AACnC,UAAM,mBAAuC,MAAM;AACnD,eAAW,CAAC,OAAO,eAAe,KAAK,iBAAiB,QAAQ,GAAG;AACjE,gBAAU,kBAAkB,SAAS,iBAAiB,qBAAqB,OAAO,QAAQ,CAAC,CAAC,GAAG;AAAA,IACjG;AAAA,EACF;AACA,SAAO;AACT;AAQO,SAAS,cAAc,eAAe,GAAW;AAEtD,QAAM,4BAA4B;AAClC,QAAM,QAAQ,kBAAkB,IAAI,MAAM,EAAE,KAAK;AACjD,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,SAAO,MAAM,MAAM,eAAe,yBAAyB,EAAE,KAAK,IAAI;AACxE;AAQO,SAAS,WAAW,OAAgB,SAAyB;AAElE,cAAY,WAAW;AACvB,UAAQ,MAAM,cAAc,KAAK,CAAC;AACpC;AAQO,SAAS,+BAA+B,SAAoD;AACjG,QAAM,WAAW,iBAAiB,GAAG,cAAc,OAAO;AAC1D,SAAO,IAAI,mBAAmB;AAAA,IAC5B,UAAU,MAAY;AACpB,uBAAiB,OAAO,QAAQ;AAAA,IAClC;AAAA,EACF,CAAC;AACH;AAQO,SAAS,gBAAgB,OAAuB;AACrD,QAAM;AACR;AAEA,SAAS,kBAAkB,SAAiB,aAAsB,OAAuB;AACvF,MAAI,SAAS,GAAG,OAAO;AAAA,EAAK,uBAAuB,KAAK,CAAC;AACzD,aAAW,QAAQ,cAAc,WAAW,EAAE,MAAM,IAAI,GAAG;AACzD,QAAI,CAAC,KAAK,KAAK,GAAG;AAChB;AAAA,IACF;AACA,cAAU,KAAK,WAAW,kBAAkB,IACxC;AAAA,EAAK,IAAI,KACT;AAAA,EAAK,uBAAuB,IAAI,CAAC;AAAA,EACvC;AACA,SAAO;AACT;AAEA,SAAS,uBAAuB,OAAuB;AACrD,SAAO,GAAG,kBAAkB,QAAQ,KAAK;AAC3C;AAOA,SAAS,iBAAiB,YAA2B;AACnD,aAAW,UAAU;AACvB;",
  "names": []
}


package/dist/lib/esm/html-element.d.mts

@@ -53,6 +53,7 @@ export declare function createDivAsync(o?: DomElementInfo | string, callback?: (
  * @param o - The element information.
  * @param callback - The callback to call when the element is created.
  * @returns A {@link Promise} that resolves to the element.
+ * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#createEl} (or createSvg, correspondingly).
  */
 export declare function createElAsync<K extends keyof HTMLElementTagNameMap>(tag: K, o?: DomElementInfo | string, callback?: (el: HTMLElementTagNameMap[K]) => Promisable<void>): Promise<HTMLElementTagNameMap[K]>;
 /**
@@ -78,6 +79,7 @@ export declare function createSpanAsync(o?: DomElementInfo | string, callback?:
  * @param o - The svg information.
  * @param callback - The callback to call when the svg is created.
  * @returns A {@link Promise} that resolves to the svg.
+ * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#createSvg} (or createEl, correspondingly).
  */
 export declare function createSvgAsync<K extends keyof SVGElementTagNameMap>(tag: K, o?: string | SvgElementInfo, callback?: (el: SVGElementTagNameMap[K]) => Promisable<void>): Promise<SVGElementTagNameMap[K]>;
 /**
@@ -113,9 +115,9 @@ export declare function isLoaded(el: Element): boolean;
  *
  * @param node - The node to add the event listener to.
  * @param callback - The callback to call when the event is triggered.
- * @returns A function to remove the event listener.
+ * @returns A {@link Disposable} that removes the event listeners when disposed, for use with `using`.
  */
-export declare function onAncestorScrollOrResize(node: Node, callback: () => void): () => void;
+export declare function onAncestorScrollOrResize(node: Node, callback: () => void): Disposable;
 /**
  * Converts a number to a string with 'px' appended.
  *