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

package/dist/lib/cjs/disposable.cjs

@@ -0,0 +1,234 @@
+/*
+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() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"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 disposable_exports = {};
+__export(disposable_exports, {
+  AsyncCallbackDisposable: () => AsyncCallbackDisposable,
+  CallbackDisposable: () => CallbackDisposable,
+  MultipleDisposeBehavior: () => MultipleDisposeBehavior,
+  isAsyncDisposable: () => isAsyncDisposable,
+  isDisposable: () => isDisposable
+});
+module.exports = __toCommonJS(disposable_exports);
+var import_type_guards = require('./type-guards.cjs');
+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:
+          (0, import_type_guards.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:
+          (0, import_type_guards.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];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,yBAA4B;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,8CAAY,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,8CAAY,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/cjs/disposable.d.cts

@@ -0,0 +1,124 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Disposable utilities for `using` / `await using` declarations.
+ */
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
+/**
+ * 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/cjs/error.cjs

@@ -138,6 +138,7 @@ __export(error_exports, {
 });
 module.exports = __toCommonJS(error_exports);
 var import_async_events = require('./async-events.cjs');
+var import_disposable = require('./disposable.cjs');
 var import_type_guards = require('./type-guards.cjs');
 const errorAsyncEvents = new import_async_events.AsyncEvents();
 errorAsyncEvents.on("asyncError", handleAsyncError);
@@ -217,16 +218,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;
@@ -243,13 +240,28 @@ function printError(error, console) {
 }
 function registerAsyncErrorEventHandler(handler) {
   const eventRef = errorAsyncEvents.on("asyncError", handler);
-  return () => {
-    errorAsyncEvents.offref(eventRef);
-  };
+  return new import_disposable.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)`;
 }
@@ -269,4 +281,4 @@ function handleAsyncError(asyncError) {
   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 * 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 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": "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",
  "names": []
}


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

@@ -74,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.
@@ -98,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/cjs/function.d.cts

@@ -4,7 +4,7 @@
  *
  * Contains utility functions and types for working with functions.
  */
-import type { Promisable } from 'type-fest';
+import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 /**
  * Represents a generic async function.
  *

package/dist/lib/cjs/html-element.cjs

@@ -140,6 +140,7 @@ __export(html_element_exports, {
   waitUntilConnected: () => waitUntilConnected
 });
 module.exports = __toCommonJS(html_element_exports);
+var import_disposable = require('./disposable.cjs');
 function appendCodeBlock(el, code) {
   el.createEl("strong", { cls: "markdown-rendered code" }, (strong) => {
     strong.createEl("code", { text: code });
@@ -249,12 +250,14 @@ function onAncestorScrollOrResize(node, callback) {
     ancestor.addEventListener("scroll", callbackSmooth, { capture: true });
     ancestor.addEventListener("resize", callbackSmooth, { capture: true });
   }
-  return () => {
-    for (const ancestor of ancestors) {
-      ancestor.removeEventListener("scroll", callbackSmooth, { capture: true });
-      ancestor.removeEventListener("resize", callbackSmooth, { capture: true });
+  return new import_disposable.CallbackDisposable({
+    callback: () => {
+      for (const ancestor of ancestors) {
+        ancestor.removeEventListener("scroll", callbackSmooth, { capture: true });
+        ancestor.removeEventListener("resize", callbackSmooth, { capture: true });
+      }
     }
-  };
+  });
   function callbackSmooth() {
     if (isEventTriggered) {
       return;
@@ -302,4 +305,4 @@ function getLoadableElements(el) {
   toPx,
   waitUntilConnected
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/html-element.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Helpers for working with HTML elements.\n */\n\nimport type { Promisable } from 'type-fest';\n\n/**\n * A HTML element that can be validated.\n */\nexport interface ValidatorElement extends HTMLElement {\n  /**\n   * Checks the validity of the element.\n   *\n   * @returns `true` if the element is valid, `false` otherwise.\n   */\n  checkValidity(): boolean;\n\n  /**\n   * Reports the validity of the element.\n   */\n  reportValidity(): boolean;\n\n  /**\n   * Sets a custom error message on the element.\n   *\n   * @param error - The error message to set on the element.\n   */\n  setCustomValidity(error: string): void;\n\n  /**\n   * An error message of the element.\n   */\n  readonly validationMessage: string;\n}\n\n/**\n * Appends a code block to the given DocumentFragment or HTMLElement.\n *\n * @param el - The DocumentFragment or HTMLElement to append the code block to.\n * @param code - The code to be displayed in the code block.\n */\nexport function appendCodeBlock(el: DocumentFragment | HTMLElement, code: string): void {\n  el.createEl('strong', { cls: 'markdown-rendered code' }, (strong) => {\n    strong.createEl('code', { text: code });\n  });\n}\n\n/**\n * Creates a div asynchronously.\n *\n * @param o - The element information.\n * @param callback - The callback to call when the div is created.\n * @returns A {@link Promise} that resolves to the div.\n */\nexport async function createDivAsync(\n  o?: DomElementInfo | string,\n  callback?: (el: HTMLDivElement) => Promisable<void>\n): Promise<HTMLDivElement> {\n  const div = createDiv(o);\n  await callback?.(div);\n  return div;\n}\n\n/**\n * Creates an element asynchronously.\n *\n * @typeParam K - The tag name key from `HTMLElementTagNameMap`.\n * @param tag - The tag name of the element to create.\n * @param o - The element information.\n * @param callback - The callback to call when the element is created.\n * @returns A {@link Promise} that resolves to the element.\n * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#createEl} (or createSvg, correspondingly).\n */\nexport async function createElAsync<K extends keyof HTMLElementTagNameMap>(\n  tag: K,\n  o?: DomElementInfo | string,\n  callback?: (el: HTMLElementTagNameMap[K]) => Promisable<void>\n): Promise<HTMLElementTagNameMap[K]> {\n  const el = createEl(tag, o);\n  await callback?.(el);\n  return el;\n}\n\n/**\n * Creates a DocumentFragment asynchronously.\n *\n * @param callback - The callback to call when the DocumentFragment is created.\n * @returns A {@link Promise} that resolves to the DocumentFragment.\n */\nexport async function createFragmentAsync(callback?: (el: DocumentFragment) => Promisable<void>): Promise<DocumentFragment> {\n  const fragment = createFragment();\n  await callback?.(fragment);\n  return fragment;\n}\n\n/**\n * Creates a span asynchronously.\n *\n * @param o - The element information.\n * @param callback - The callback to call when the span is created.\n * @returns A {@link Promise} that resolves to the span.\n */\nexport async function createSpanAsync(\n  o?: DomElementInfo | string,\n  callback?: (el: HTMLSpanElement) => Promisable<void>\n): Promise<HTMLSpanElement> {\n  const span = createSpan(o);\n  await callback?.(span);\n  return span;\n}\n\n/**\n * Creates a svg asynchronously.\n *\n * @typeParam K - The tag name key from `SVGElementTagNameMap`.\n * @param tag - The tag name of the svg to create.\n * @param o - The svg information.\n * @param callback - The callback to call when the svg is created.\n * @returns A {@link Promise} that resolves to the svg.\n * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#createSvg} (or createEl, correspondingly).\n */\nexport async function createSvgAsync<K extends keyof SVGElementTagNameMap>(\n  tag: K,\n  o?: string | SvgElementInfo,\n  callback?: (el: SVGElementTagNameMap[K]) => Promisable<void>\n): Promise<SVGElementTagNameMap[K]> {\n  const svg = createSvg(tag, o);\n  await callback?.(svg);\n  return svg;\n}\n\n/**\n * Ensures that the given element is loaded.\n *\n * @param el - The element to ensure is loaded.\n * @returns A {@link Promise} that resolves when the element is loaded.\n */\nexport async function ensureLoaded(el: Element): Promise<void> {\n  if (isLoaded(el)) {\n    return;\n  }\n  if (\n    el.instanceOf(HTMLBodyElement)\n    || el.instanceOf(HTMLImageElement)\n    || el.instanceOf(HTMLIFrameElement)\n    || el.instanceOf(HTMLEmbedElement)\n    || el.instanceOf(HTMLLinkElement)\n    || el.instanceOf(HTMLObjectElement)\n    || el.instanceOf(HTMLStyleElement)\n    || el.instanceOf(HTMLTrackElement)\n  ) {\n    await new Promise((resolve) => {\n      el.addEventListener('load', resolve);\n      el.addEventListener('error', resolve);\n    });\n    return;\n  }\n\n  await Promise.all(getLoadableElements(el).map(ensureLoaded));\n}\n\n/**\n * Gets the z-index of the given element.\n *\n * @param el - The element to get the z-index of.\n * @returns The z-index of the element.\n */\nexport function getZIndex(el: Element): number {\n  let el2: Element | null = el;\n\n  while (el2) {\n    const zIndexStr = getComputedStyle(el2).zIndex;\n    const zIndex = Number.parseInt(zIndexStr, 10);\n    if (!Number.isNaN(zIndex)) {\n      return zIndex;\n    }\n    el2 = el2.parentElement;\n  }\n\n  return 0;\n}\n\n/**\n * Checks if the element is visible in the offset parent.\n *\n * @param el - The element to check.\n * @returns `true` if the element is visible in the offset parent, `false` otherwise.\n */\nexport function isElementVisibleInOffsetParent(el: HTMLElement): boolean {\n  const parentEl = el.offsetParent;\n  if (!parentEl) {\n    return false;\n  }\n\n  const elRect = el.getBoundingClientRect();\n  const parentElRect = parentEl.getBoundingClientRect();\n\n  return (\n    parentElRect.top <= elRect.top\n    && elRect.bottom <= parentElRect.bottom\n    && parentElRect.left <= elRect.left\n    && elRect.right <= parentElRect.right\n  );\n}\n\n/**\n * Checks if the element is loaded.\n *\n * @param el - The element to check.\n * @returns `true` if the element is loaded, `false` otherwise.\n */\nexport function isLoaded(el: Element): boolean {\n  if (el.instanceOf(HTMLBodyElement)) {\n    return activeDocument.readyState === 'complete' || activeDocument.readyState === 'interactive';\n  }\n\n  if (el.instanceOf(HTMLImageElement)) {\n    return el.complete && el.naturalWidth > 0;\n  }\n\n  if (el.instanceOf(HTMLIFrameElement)) {\n    return !!el.contentDocument;\n  }\n\n  if (el.instanceOf(HTMLEmbedElement)) {\n    return !!el.getSVGDocument();\n  }\n\n  if (el.instanceOf(HTMLLinkElement)) {\n    return el.rel === 'stylesheet' ? el.sheet !== null : true;\n  }\n\n  if (el.instanceOf(HTMLObjectElement)) {\n    return !!el.contentDocument || !!el.getSVGDocument();\n  }\n\n  if (el.instanceOf(HTMLScriptElement)) {\n    return true;\n  }\n\n  if (el.instanceOf(HTMLStyleElement)) {\n    return !!el.sheet;\n  }\n\n  if (el.instanceOf(HTMLTrackElement)) {\n    const READY_STATE_LOADED = 2;\n    return el.readyState === READY_STATE_LOADED;\n  }\n\n  return getLoadableElements(el).every(isLoaded);\n}\n\n/**\n * Adds an event listener to the ancestor nodes of the given node.\n *\n * @param node - The node to add the event listener to.\n * @param callback - The callback to call when the event is triggered.\n * @returns A function to remove the event listener.\n */\nexport function onAncestorScrollOrResize(node: Node, callback: () => void): () => void {\n  const ancestors: EventTarget[] = [];\n  ancestors.push(activeDocument);\n  ancestors.push(activeWindow);\n\n  let currentNode: Node | null = node;\n\n  while (currentNode) {\n    ancestors.push(currentNode);\n    currentNode = currentNode.parentNode;\n  }\n\n  let isEventTriggered = false;\n\n  for (const ancestor of ancestors) {\n    ancestor.addEventListener('scroll', callbackSmooth, { capture: true });\n    ancestor.addEventListener('resize', callbackSmooth, { capture: true });\n  }\n\n  return () => {\n    for (const ancestor of ancestors) {\n      ancestor.removeEventListener('scroll', callbackSmooth, { capture: true });\n      ancestor.removeEventListener('resize', callbackSmooth, { capture: true });\n    }\n  };\n\n  function callbackSmooth(): void {\n    if (isEventTriggered) {\n      return;\n    }\n\n    isEventTriggered = true;\n\n    window.requestAnimationFrame(() => {\n      try {\n        callback();\n      } finally {\n        isEventTriggered = false;\n      }\n    });\n  }\n}\n\n/**\n * Converts a number to a string with 'px' appended.\n *\n * @param value - The number to convert.\n * @returns The number as a string with 'px' appended.\n */\nexport function toPx(value: number): string {\n  return `${String(value)}px`;\n}\n\n/**\n * Waits until the given element is connected to the DOM.\n *\n * @param el - The element to check.\n * @returns A promise that resolves when the element is connected.\n */\nexport function waitUntilConnected(el: HTMLElement): Promise<void> {\n  return new Promise((resolve) => {\n    if (el.isConnected) {\n      resolve();\n    } else {\n      el.onNodeInserted(() => {\n        resolve();\n      }, true);\n    }\n  });\n}\n\nfunction getLoadableElements(el: Element): Element[] {\n  return Array.from(el.querySelectorAll('body, img, iframe, embed, link, object, script, style, track'));\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/html-element.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Helpers for working with HTML elements.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { CallbackDisposable } from './disposable.ts';\n\n/**\n * A HTML element that can be validated.\n */\nexport interface ValidatorElement extends HTMLElement {\n  /**\n   * Checks the validity of the element.\n   *\n   * @returns `true` if the element is valid, `false` otherwise.\n   */\n  checkValidity(): boolean;\n\n  /**\n   * Reports the validity of the element.\n   */\n  reportValidity(): boolean;\n\n  /**\n   * Sets a custom error message on the element.\n   *\n   * @param error - The error message to set on the element.\n   */\n  setCustomValidity(error: string): void;\n\n  /**\n   * An error message of the element.\n   */\n  readonly validationMessage: string;\n}\n\n/**\n * Appends a code block to the given DocumentFragment or HTMLElement.\n *\n * @param el - The DocumentFragment or HTMLElement to append the code block to.\n * @param code - The code to be displayed in the code block.\n */\nexport function appendCodeBlock(el: DocumentFragment | HTMLElement, code: string): void {\n  el.createEl('strong', { cls: 'markdown-rendered code' }, (strong) => {\n    strong.createEl('code', { text: code });\n  });\n}\n\n/**\n * Creates a div asynchronously.\n *\n * @param o - The element information.\n * @param callback - The callback to call when the div is created.\n * @returns A {@link Promise} that resolves to the div.\n */\nexport async function createDivAsync(\n  o?: DomElementInfo | string,\n  callback?: (el: HTMLDivElement) => Promisable<void>\n): Promise<HTMLDivElement> {\n  const div = createDiv(o);\n  await callback?.(div);\n  return div;\n}\n\n/**\n * Creates an element asynchronously.\n *\n * @typeParam K - The tag name key from `HTMLElementTagNameMap`.\n * @param tag - The tag name of the element to create.\n * @param o - The element information.\n * @param callback - The callback to call when the element is created.\n * @returns A {@link Promise} that resolves to the element.\n * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#createEl} (or createSvg, correspondingly).\n */\nexport async function createElAsync<K extends keyof HTMLElementTagNameMap>(\n  tag: K,\n  o?: DomElementInfo | string,\n  callback?: (el: HTMLElementTagNameMap[K]) => Promisable<void>\n): Promise<HTMLElementTagNameMap[K]> {\n  const el = createEl(tag, o);\n  await callback?.(el);\n  return el;\n}\n\n/**\n * Creates a DocumentFragment asynchronously.\n *\n * @param callback - The callback to call when the DocumentFragment is created.\n * @returns A {@link Promise} that resolves to the DocumentFragment.\n */\nexport async function createFragmentAsync(callback?: (el: DocumentFragment) => Promisable<void>): Promise<DocumentFragment> {\n  const fragment = createFragment();\n  await callback?.(fragment);\n  return fragment;\n}\n\n/**\n * Creates a span asynchronously.\n *\n * @param o - The element information.\n * @param callback - The callback to call when the span is created.\n * @returns A {@link Promise} that resolves to the span.\n */\nexport async function createSpanAsync(\n  o?: DomElementInfo | string,\n  callback?: (el: HTMLSpanElement) => Promisable<void>\n): Promise<HTMLSpanElement> {\n  const span = createSpan(o);\n  await callback?.(span);\n  return span;\n}\n\n/**\n * Creates a svg asynchronously.\n *\n * @typeParam K - The tag name key from `SVGElementTagNameMap`.\n * @param tag - The tag name of the svg to create.\n * @param o - The svg information.\n * @param callback - The callback to call when the svg is created.\n * @returns A {@link Promise} that resolves to the svg.\n * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#createSvg} (or createEl, correspondingly).\n */\nexport async function createSvgAsync<K extends keyof SVGElementTagNameMap>(\n  tag: K,\n  o?: string | SvgElementInfo,\n  callback?: (el: SVGElementTagNameMap[K]) => Promisable<void>\n): Promise<SVGElementTagNameMap[K]> {\n  const svg = createSvg(tag, o);\n  await callback?.(svg);\n  return svg;\n}\n\n/**\n * Ensures that the given element is loaded.\n *\n * @param el - The element to ensure is loaded.\n * @returns A {@link Promise} that resolves when the element is loaded.\n */\nexport async function ensureLoaded(el: Element): Promise<void> {\n  if (isLoaded(el)) {\n    return;\n  }\n  if (\n    el.instanceOf(HTMLBodyElement)\n    || el.instanceOf(HTMLImageElement)\n    || el.instanceOf(HTMLIFrameElement)\n    || el.instanceOf(HTMLEmbedElement)\n    || el.instanceOf(HTMLLinkElement)\n    || el.instanceOf(HTMLObjectElement)\n    || el.instanceOf(HTMLStyleElement)\n    || el.instanceOf(HTMLTrackElement)\n  ) {\n    await new Promise((resolve) => {\n      el.addEventListener('load', resolve);\n      el.addEventListener('error', resolve);\n    });\n    return;\n  }\n\n  await Promise.all(getLoadableElements(el).map(ensureLoaded));\n}\n\n/**\n * Gets the z-index of the given element.\n *\n * @param el - The element to get the z-index of.\n * @returns The z-index of the element.\n */\nexport function getZIndex(el: Element): number {\n  let el2: Element | null = el;\n\n  while (el2) {\n    const zIndexStr = getComputedStyle(el2).zIndex;\n    const zIndex = Number.parseInt(zIndexStr, 10);\n    if (!Number.isNaN(zIndex)) {\n      return zIndex;\n    }\n    el2 = el2.parentElement;\n  }\n\n  return 0;\n}\n\n/**\n * Checks if the element is visible in the offset parent.\n *\n * @param el - The element to check.\n * @returns `true` if the element is visible in the offset parent, `false` otherwise.\n */\nexport function isElementVisibleInOffsetParent(el: HTMLElement): boolean {\n  const parentEl = el.offsetParent;\n  if (!parentEl) {\n    return false;\n  }\n\n  const elRect = el.getBoundingClientRect();\n  const parentElRect = parentEl.getBoundingClientRect();\n\n  return (\n    parentElRect.top <= elRect.top\n    && elRect.bottom <= parentElRect.bottom\n    && parentElRect.left <= elRect.left\n    && elRect.right <= parentElRect.right\n  );\n}\n\n/**\n * Checks if the element is loaded.\n *\n * @param el - The element to check.\n * @returns `true` if the element is loaded, `false` otherwise.\n */\nexport function isLoaded(el: Element): boolean {\n  if (el.instanceOf(HTMLBodyElement)) {\n    return activeDocument.readyState === 'complete' || activeDocument.readyState === 'interactive';\n  }\n\n  if (el.instanceOf(HTMLImageElement)) {\n    return el.complete && el.naturalWidth > 0;\n  }\n\n  if (el.instanceOf(HTMLIFrameElement)) {\n    return !!el.contentDocument;\n  }\n\n  if (el.instanceOf(HTMLEmbedElement)) {\n    return !!el.getSVGDocument();\n  }\n\n  if (el.instanceOf(HTMLLinkElement)) {\n    return el.rel === 'stylesheet' ? el.sheet !== null : true;\n  }\n\n  if (el.instanceOf(HTMLObjectElement)) {\n    return !!el.contentDocument || !!el.getSVGDocument();\n  }\n\n  if (el.instanceOf(HTMLScriptElement)) {\n    return true;\n  }\n\n  if (el.instanceOf(HTMLStyleElement)) {\n    return !!el.sheet;\n  }\n\n  if (el.instanceOf(HTMLTrackElement)) {\n    const READY_STATE_LOADED = 2;\n    return el.readyState === READY_STATE_LOADED;\n  }\n\n  return getLoadableElements(el).every(isLoaded);\n}\n\n/**\n * Adds an event listener to the ancestor nodes of the given node.\n *\n * @param node - The node to add the event listener to.\n * @param callback - The callback to call when the event is triggered.\n * @returns A {@link Disposable} that removes the event listeners when disposed, for use with `using`.\n */\nexport function onAncestorScrollOrResize(node: Node, callback: () => void): Disposable {\n  const ancestors: EventTarget[] = [];\n  ancestors.push(activeDocument);\n  ancestors.push(activeWindow);\n\n  let currentNode: Node | null = node;\n\n  while (currentNode) {\n    ancestors.push(currentNode);\n    currentNode = currentNode.parentNode;\n  }\n\n  let isEventTriggered = false;\n\n  for (const ancestor of ancestors) {\n    ancestor.addEventListener('scroll', callbackSmooth, { capture: true });\n    ancestor.addEventListener('resize', callbackSmooth, { capture: true });\n  }\n\n  return new CallbackDisposable({\n    callback: (): void => {\n      for (const ancestor of ancestors) {\n        ancestor.removeEventListener('scroll', callbackSmooth, { capture: true });\n        ancestor.removeEventListener('resize', callbackSmooth, { capture: true });\n      }\n    }\n  });\n\n  function callbackSmooth(): void {\n    if (isEventTriggered) {\n      return;\n    }\n\n    isEventTriggered = true;\n\n    window.requestAnimationFrame(() => {\n      try {\n        callback();\n      } finally {\n        isEventTriggered = false;\n      }\n    });\n  }\n}\n\n/**\n * Converts a number to a string with 'px' appended.\n *\n * @param value - The number to convert.\n * @returns The number as a string with 'px' appended.\n */\nexport function toPx(value: number): string {\n  return `${String(value)}px`;\n}\n\n/**\n * Waits until the given element is connected to the DOM.\n *\n * @param el - The element to check.\n * @returns A promise that resolves when the element is connected.\n */\nexport function waitUntilConnected(el: HTMLElement): Promise<void> {\n  return new Promise((resolve) => {\n    if (el.isConnected) {\n      resolve();\n    } else {\n      el.onNodeInserted(() => {\n        resolve();\n      }, true);\n    }\n  });\n}\n\nfunction getLoadableElements(el: Element): Element[] {\n  return Array.from(el.querySelectorAll('body, img, iframe, embed, link, object, script, style, track'));\n}\n"],
  "mappings": "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",
  "names": []
}
