@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/loop.mjs

@@ -3,11 +3,6 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 (function () {
-function ensureDisposeSymbols(symbolConstructor = Symbol) {
-  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
-  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
-}
-
 function ensureBrowserProcess() {
   const browserProcess = {
     browser: true,
@@ -32,7 +27,6 @@ function ensureBrowserProcess() {
   existingProcessRecord["browser"] = true;
 }
 
-ensureDisposeSymbols();
 ensureBrowserProcess();
 })();
 
@@ -136,7 +130,7 @@ async function loop(params) {
       await noticeMinTimeoutPromise;
     }
   } finally {
-    delayedNotice?.[Symbol.dispose]();
+    delayedNotice?.dispose();
   }
   function buildProgressBarFragment() {
     const fragment = createFragment();
@@ -148,4 +142,4 @@ async function loop(params) {
 export {
   loop
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/loop.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains utility functions for looping in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { abortSignalNever } from '@mnaoumov/typescript-lib/abort-controller';\nimport { requestAnimationFrameAsync } from '@mnaoumov/typescript-lib/async';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace\n} from '@mnaoumov/typescript-lib/error';\nimport { noop } from '@mnaoumov/typescript-lib/function';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { reportBulkOperationProgress } from './bulk-operation-progress.ts';\nimport { getObsidianLibDebugger } from './debug.ts';\nimport { appendTextOrFragmentClone } from './html-element.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * Parameters for the {@link LoopParams.buildNoticeMessage} callback.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopBuildNoticeMessageParams<T> {\n  /**\n   * The current item.\n   */\n  readonly item: T;\n\n  /**\n   * A string representing the current iteration.\n   */\n  readonly iterationString: string;\n}\n\n/**\n * Options for {@link loop}.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopParams<T> {\n  /**\n   * An optional abort signal to cancel the loop.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Build a notice message for each item.\n   *\n   * @param params - The parameters for building the notice message.\n   * @returns A string to display in the notice.\n   */\n  readonly buildNoticeMessage: (params: LoopBuildNoticeMessageParams<T>) => string;\n\n  /**\n   * Items to loop over.\n   */\n  readonly items: T[];\n\n  /**\n   * A timeout for the notice before it is shown.\n   *\n   * @default `500`\n   */\n  readonly noticeBeforeShownTimeoutInMilliseconds?: number;\n\n  /**\n   * A minimum timeout for the notice.\n   *\n   * @default `2000`\n   */\n  readonly noticeMinTimeoutInMilliseconds?: number;\n\n  /**\n   * A component to show notices.\n   */\n  readonly pluginNoticeComponent: null | PluginNoticeComponent;\n\n  /**\n   * Process each item.\n   *\n   * @param item - The current item.\n   */\n  readonly processItem: (item: T) => Promisable<void>;\n\n  /**\n   * A title of the progress bar.\n   *\n   * Pass a {@link DocumentFragment} to mark up part of the title, such as a plugin name rendered as code. Each\n   * render appends a fresh clone of it, so the caller's fragment stays intact.\n   *\n   * @default `''`\n   */\n  readonly progressBarTitle?: DocumentFragment | string;\n\n  /**\n   * Whether to continue the loop on error.\n   *\n   * @default `true`\n   */\n  readonly shouldContinueOnError?: boolean;\n\n  /**\n   * Whether to show a notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowNotice?: boolean;\n\n  /**\n   * Whether to show a progress bar.\n   *\n   * @default `true`\n   */\n  readonly shouldShowProgressBar?: boolean;\n\n  /**\n   * A threshold for the UI update.\n   *\n   * @default `100`\n   */\n  readonly uiUpdateThresholdInMilliseconds?: number;\n}\n\n/**\n * Loops over a list of items and processes each item.\n *\n * @typeParam T - The type of the items to loop over.\n * @param params - The parameters for the loop.\n */\nexport async function loop<T>(params: LoopParams<T>): Promise<void> {\n  const DEFAULT_OPTIONS = {\n    abortSignal: abortSignalNever(),\n    /* v8 ignore start -- buildNoticeMessage is required in LoopParams and always overridden by the spread. */\n    buildNoticeMessage(): string {\n      throw new Error('buildNoticeMessage is required');\n    },\n    /* v8 ignore stop */\n    items: [],\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeBeforeShownTimeoutInMilliseconds: 500,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeMinTimeoutInMilliseconds: 2000,\n    processItem: noop,\n    progressBarTitle: '',\n    shouldContinueOnError: true,\n    shouldShowNotice: true,\n    shouldShowProgressBar: true,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    uiUpdateThresholdInMilliseconds: 100\n  };\n\n  const fullOptions: Required<LoopParams<T>> = {\n    ...DEFAULT_OPTIONS,\n    ...params\n  };\n\n  const stackTrace = getStackTrace(1);\n\n  const items = fullOptions.items;\n  let iterationCount = 0;\n\n  const progressBarEl = createEl('progress');\n  addPluginCssClasses(progressBarEl, 'loop');\n  progressBarEl.max = items.length;\n\n  // The content provider is resolved only once the delay elapses, so it doubles as the notice-was-shown signal.\n  let isNoticeShown = false as boolean;\n  let latestMessage = '';\n  // A delayed notice stays until it is disposed. Obsidian's default duration would hide it a few seconds into a\n  // long run while the loop carries on.\n  const delayedNotice = fullOptions.shouldShowNotice\n    ? params.pluginNoticeComponent?.showNoticeAfterDelay({\n      content: () => {\n        isNoticeShown = true;\n        return fullOptions.shouldShowProgressBar ? buildProgressBarFragment() : latestMessage;\n      },\n      delayInMilliseconds: fullOptions.noticeBeforeShownTimeoutInMilliseconds\n    }) ?? null\n    : null;\n\n  const noticeMinTimeoutPromise = sleep(fullOptions.noticeMinTimeoutInMilliseconds);\n  let lastUIUpdateTimestamp = performance.now();\n\n  try {\n    for (const item of items) {\n      if (fullOptions.abortSignal.aborted) {\n        return;\n      }\n      iterationCount++;\n      const iterationString = `# ${String(iterationCount)} / ${String(items.length)}`;\n      const message = fullOptions.buildNoticeMessage({ item, iterationString });\n      if (!fullOptions.shouldShowProgressBar) {\n        latestMessage = message;\n        if (isNoticeShown) {\n          delayedNotice?.setContent(message);\n        }\n      }\n      getObsidianLibDebugger('Loop')(message);\n\n      try {\n        if (performance.now() - lastUIUpdateTimestamp > fullOptions.uiUpdateThresholdInMilliseconds) {\n          await requestAnimationFrameAsync();\n          lastUIUpdateTimestamp = performance.now();\n        }\n        await fullOptions.processItem(item);\n      } catch (error) {\n        console.error('Error processing item', item);\n        if (!fullOptions.shouldContinueOnError) {\n          throw new CustomStackTraceError({\n            cause: error,\n            message: 'loop failed',\n            stackTrace\n          });\n        }\n\n        emitAsyncErrorEvent(\n          new CustomStackTraceError({\n            cause: error,\n            message: ASYNC_WRAPPER_ERROR_MESSAGE,\n            stackTrace\n          })\n        );\n      }\n      progressBarEl.value++;\n      reportBulkOperationProgress();\n    }\n    if (isNoticeShown) {\n      await noticeMinTimeoutPromise;\n    }\n  } finally {\n    // Disposed by an explicit call rather than a `using` declaration: `using` looks the method up under a different\n    // key than the handle is built with on an engine lacking `Symbol.dispose`, and `loop()` runs on every platform.\n    delayedNotice?.[Symbol.dispose]();\n  }\n\n  function buildProgressBarFragment(): DocumentFragment {\n    const fragment = createFragment();\n    appendTextOrFragmentClone(fragment.createDiv(), fullOptions.progressBarTitle);\n    fragment.append(progressBarEl);\n    return fragment;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,wBAAwB;AACjC,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AAIrB,SAAS,mCAAmC;AAC5C,SAAS,8BAA8B;AACvC,SAAS,iCAAiC;AAC1C,SAAS,2BAA2B;AAkHpC,eAAsB,KAAQ,QAAsC;AAClE,QAAM,kBAAkB;AAAA,IACtB,aAAa,iBAAiB;AAAA;AAAA,IAE9B,qBAA6B;AAC3B,YAAM,IAAI,MAAM,gCAAgC;AAAA,IAClD;AAAA;AAAA,IAEA,OAAO,CAAC;AAAA;AAAA,IAER,wCAAwC;AAAA;AAAA,IAExC,gCAAgC;AAAA,IAChC,aAAa;AAAA,IACb,kBAAkB;AAAA,IAClB,uBAAuB;AAAA,IACvB,kBAAkB;AAAA,IAClB,uBAAuB;AAAA;AAAA,IAEvB,iCAAiC;AAAA,EACnC;AAEA,QAAM,cAAuC;AAAA,IAC3C,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,QAAM,aAAa,cAAc,CAAC;AAElC,QAAM,QAAQ,YAAY;AAC1B,MAAI,iBAAiB;AAErB,QAAM,gBAAgB,SAAS,UAAU;AACzC,sBAAoB,eAAe,MAAM;AACzC,gBAAc,MAAM,MAAM;AAG1B,MAAI,gBAAgB;AACpB,MAAI,gBAAgB;AAGpB,QAAM,gBAAgB,YAAY,mBAC9B,OAAO,uBAAuB,qBAAqB;AAAA,IACnD,SAAS,MAAM;AACb,sBAAgB;AAChB,aAAO,YAAY,wBAAwB,yBAAyB,IAAI;AAAA,IAC1E;AAAA,IACA,qBAAqB,YAAY;AAAA,EACnC,CAAC,KAAK,OACJ;AAEJ,QAAM,0BAA0B,MAAM,YAAY,8BAA8B;AAChF,MAAI,wBAAwB,YAAY,IAAI;AAE5C,MAAI;AACF,eAAW,QAAQ,OAAO;AACxB,UAAI,YAAY,YAAY,SAAS;AACnC;AAAA,MACF;AACA;AACA,YAAM,kBAAkB,KAAK,OAAO,cAAc,CAAC,MAAM,OAAO,MAAM,MAAM,CAAC;AAC7E,YAAM,UAAU,YAAY,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,UAAI,CAAC,YAAY,uBAAuB;AACtC,wBAAgB;AAChB,YAAI,eAAe;AACjB,yBAAe,WAAW,OAAO;AAAA,QACnC;AAAA,MACF;AACA,6BAAuB,MAAM,EAAE,OAAO;AAEtC,UAAI;AACF,YAAI,YAAY,IAAI,IAAI,wBAAwB,YAAY,iCAAiC;AAC3F,gBAAM,2BAA2B;AACjC,kCAAwB,YAAY,IAAI;AAAA,QAC1C;AACA,cAAM,YAAY,YAAY,IAAI;AAAA,MACpC,SAAS,OAAO;AACd,gBAAQ,MAAM,yBAAyB,IAAI;AAC3C,YAAI,CAAC,YAAY,uBAAuB;AACtC,gBAAM,IAAI,sBAAsB;AAAA,YAC9B,OAAO;AAAA,YACP,SAAS;AAAA,YACT;AAAA,UACF,CAAC;AAAA,QACH;AAEA;AAAA,UACE,IAAI,sBAAsB;AAAA,YACxB,OAAO;AAAA,YACP,SAAS;AAAA,YACT;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AACA,oBAAc;AACd,kCAA4B;AAAA,IAC9B;AACA,QAAI,eAAe;AACjB,YAAM;AAAA,IACR;AAAA,EACF,UAAE;AAGA,oBAAgB,OAAO,OAAO,EAAE;AAAA,EAClC;AAEA,WAAS,2BAA6C;AACpD,UAAM,WAAW,eAAe;AAChC,8BAA0B,SAAS,UAAU,GAAG,YAAY,gBAAgB;AAC5E,aAAS,OAAO,aAAa;AAC7B,WAAO;AAAA,EACT;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/loop.ts"],"sourcesContent":["/**\n * @file\n *\n * Contains utility functions for looping in Obsidian.\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { abortSignalNever } from '@mnaoumov/typescript-lib/abort-controller';\nimport { requestAnimationFrameAsync } from '@mnaoumov/typescript-lib/async';\nimport {\n  ASYNC_WRAPPER_ERROR_MESSAGE,\n  CustomStackTraceError,\n  emitAsyncErrorEvent,\n  getStackTrace\n} from '@mnaoumov/typescript-lib/error';\nimport { noop } from '@mnaoumov/typescript-lib/function';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { reportBulkOperationProgress } from './bulk-operation-progress.ts';\nimport { getObsidianLibDebugger } from './debug.ts';\nimport { appendTextOrFragmentClone } from './html-element.ts';\nimport { addPluginCssClasses } from './plugin/plugin-context.ts';\n\n/**\n * Parameters for the {@link LoopParams.buildNoticeMessage} callback.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopBuildNoticeMessageParams<T> {\n  /**\n   * The current item.\n   */\n  readonly item: T;\n\n  /**\n   * A string representing the current iteration.\n   */\n  readonly iterationString: string;\n}\n\n/**\n * Options for {@link loop}.\n *\n * @typeParam T - The type of the items to loop over.\n */\nexport interface LoopParams<T> {\n  /**\n   * An optional abort signal to cancel the loop.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Build a notice message for each item.\n   *\n   * @param params - The parameters for building the notice message.\n   * @returns A string to display in the notice.\n   */\n  readonly buildNoticeMessage: (params: LoopBuildNoticeMessageParams<T>) => string;\n\n  /**\n   * Items to loop over.\n   */\n  readonly items: T[];\n\n  /**\n   * A timeout for the notice before it is shown.\n   *\n   * @default `500`\n   */\n  readonly noticeBeforeShownTimeoutInMilliseconds?: number;\n\n  /**\n   * A minimum timeout for the notice.\n   *\n   * @default `2000`\n   */\n  readonly noticeMinTimeoutInMilliseconds?: number;\n\n  /**\n   * A component to show notices.\n   */\n  readonly pluginNoticeComponent: null | PluginNoticeComponent;\n\n  /**\n   * Process each item.\n   *\n   * @param item - The current item.\n   */\n  readonly processItem: (item: T) => Promisable<void>;\n\n  /**\n   * A title of the progress bar.\n   *\n   * Pass a {@link DocumentFragment} to mark up part of the title, such as a plugin name rendered as code. Each\n   * render appends a fresh clone of it, so the caller's fragment stays intact.\n   *\n   * @default `''`\n   */\n  readonly progressBarTitle?: DocumentFragment | string;\n\n  /**\n   * Whether to continue the loop on error.\n   *\n   * @default `true`\n   */\n  readonly shouldContinueOnError?: boolean;\n\n  /**\n   * Whether to show a notice.\n   *\n   * @default `true`\n   */\n  readonly shouldShowNotice?: boolean;\n\n  /**\n   * Whether to show a progress bar.\n   *\n   * @default `true`\n   */\n  readonly shouldShowProgressBar?: boolean;\n\n  /**\n   * A threshold for the UI update.\n   *\n   * @default `100`\n   */\n  readonly uiUpdateThresholdInMilliseconds?: number;\n}\n\n/**\n * Loops over a list of items and processes each item.\n *\n * @typeParam T - The type of the items to loop over.\n * @param params - The parameters for the loop.\n */\nexport async function loop<T>(params: LoopParams<T>): Promise<void> {\n  const DEFAULT_OPTIONS = {\n    abortSignal: abortSignalNever(),\n    /* v8 ignore start -- buildNoticeMessage is required in LoopParams and always overridden by the spread. */\n    buildNoticeMessage(): string {\n      throw new Error('buildNoticeMessage is required');\n    },\n    /* v8 ignore stop */\n    items: [],\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeBeforeShownTimeoutInMilliseconds: 500,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    noticeMinTimeoutInMilliseconds: 2000,\n    processItem: noop,\n    progressBarTitle: '',\n    shouldContinueOnError: true,\n    shouldShowNotice: true,\n    shouldShowProgressBar: true,\n    // eslint-disable-next-line no-magic-numbers -- Extracting magic number as a constant would be repetitive, as the value is used only once and its name would be the same as the property.\n    uiUpdateThresholdInMilliseconds: 100\n  };\n\n  const fullOptions: Required<LoopParams<T>> = {\n    ...DEFAULT_OPTIONS,\n    ...params\n  };\n\n  const stackTrace = getStackTrace(1);\n\n  const items = fullOptions.items;\n  let iterationCount = 0;\n\n  const progressBarEl = createEl('progress');\n  addPluginCssClasses(progressBarEl, 'loop');\n  progressBarEl.max = items.length;\n\n  // The content provider is resolved only once the delay elapses, so it doubles as the notice-was-shown signal.\n  let isNoticeShown = false as boolean;\n  let latestMessage = '';\n  // A delayed notice stays until it is disposed. Obsidian's default duration would hide it a few seconds into a\n  // long run while the loop carries on.\n  const delayedNotice = fullOptions.shouldShowNotice\n    ? params.pluginNoticeComponent?.showNoticeAfterDelay({\n      content: () => {\n        isNoticeShown = true;\n        return fullOptions.shouldShowProgressBar ? buildProgressBarFragment() : latestMessage;\n      },\n      delayInMilliseconds: fullOptions.noticeBeforeShownTimeoutInMilliseconds\n    }) ?? null\n    : null;\n\n  const noticeMinTimeoutPromise = sleep(fullOptions.noticeMinTimeoutInMilliseconds);\n  let lastUIUpdateTimestamp = performance.now();\n\n  try {\n    for (const item of items) {\n      if (fullOptions.abortSignal.aborted) {\n        return;\n      }\n      iterationCount++;\n      const iterationString = `# ${String(iterationCount)} / ${String(items.length)}`;\n      const message = fullOptions.buildNoticeMessage({ item, iterationString });\n      if (!fullOptions.shouldShowProgressBar) {\n        latestMessage = message;\n        if (isNoticeShown) {\n          delayedNotice?.setContent(message);\n        }\n      }\n      getObsidianLibDebugger('Loop')(message);\n\n      try {\n        if (performance.now() - lastUIUpdateTimestamp > fullOptions.uiUpdateThresholdInMilliseconds) {\n          await requestAnimationFrameAsync();\n          lastUIUpdateTimestamp = performance.now();\n        }\n        await fullOptions.processItem(item);\n      } catch (error) {\n        console.error('Error processing item', item);\n        if (!fullOptions.shouldContinueOnError) {\n          throw new CustomStackTraceError({\n            cause: error,\n            message: 'loop failed',\n            stackTrace\n          });\n        }\n\n        emitAsyncErrorEvent(\n          new CustomStackTraceError({\n            cause: error,\n            message: ASYNC_WRAPPER_ERROR_MESSAGE,\n            stackTrace\n          })\n        );\n      }\n      progressBarEl.value++;\n      reportBulkOperationProgress();\n    }\n    if (isNoticeShown) {\n      await noticeMinTimeoutPromise;\n    }\n  } finally {\n    // Disposed by an explicit `dispose()` call rather than a `using` declaration: `using` looks the method up under a\n    // different key than the handle is built with on an engine lacking `Symbol.dispose`, and `loop()` runs on every\n    // platform.\n    delayedNotice?.dispose();\n  }\n\n  function buildProgressBarFragment(): DocumentFragment {\n    const fragment = createFragment();\n    appendTextOrFragmentClone(fragment.createDiv(), fullOptions.progressBarTitle);\n    fragment.append(progressBarEl);\n    return fragment;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,wBAAwB;AACjC,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AAIrB,SAAS,mCAAmC;AAC5C,SAAS,8BAA8B;AACvC,SAAS,iCAAiC;AAC1C,SAAS,2BAA2B;AAkHpC,eAAsB,KAAQ,QAAsC;AAClE,QAAM,kBAAkB;AAAA,IACtB,aAAa,iBAAiB;AAAA;AAAA,IAE9B,qBAA6B;AAC3B,YAAM,IAAI,MAAM,gCAAgC;AAAA,IAClD;AAAA;AAAA,IAEA,OAAO,CAAC;AAAA;AAAA,IAER,wCAAwC;AAAA;AAAA,IAExC,gCAAgC;AAAA,IAChC,aAAa;AAAA,IACb,kBAAkB;AAAA,IAClB,uBAAuB;AAAA,IACvB,kBAAkB;AAAA,IAClB,uBAAuB;AAAA;AAAA,IAEvB,iCAAiC;AAAA,EACnC;AAEA,QAAM,cAAuC;AAAA,IAC3C,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AAEA,QAAM,aAAa,cAAc,CAAC;AAElC,QAAM,QAAQ,YAAY;AAC1B,MAAI,iBAAiB;AAErB,QAAM,gBAAgB,SAAS,UAAU;AACzC,sBAAoB,eAAe,MAAM;AACzC,gBAAc,MAAM,MAAM;AAG1B,MAAI,gBAAgB;AACpB,MAAI,gBAAgB;AAGpB,QAAM,gBAAgB,YAAY,mBAC9B,OAAO,uBAAuB,qBAAqB;AAAA,IACnD,SAAS,MAAM;AACb,sBAAgB;AAChB,aAAO,YAAY,wBAAwB,yBAAyB,IAAI;AAAA,IAC1E;AAAA,IACA,qBAAqB,YAAY;AAAA,EACnC,CAAC,KAAK,OACJ;AAEJ,QAAM,0BAA0B,MAAM,YAAY,8BAA8B;AAChF,MAAI,wBAAwB,YAAY,IAAI;AAE5C,MAAI;AACF,eAAW,QAAQ,OAAO;AACxB,UAAI,YAAY,YAAY,SAAS;AACnC;AAAA,MACF;AACA;AACA,YAAM,kBAAkB,KAAK,OAAO,cAAc,CAAC,MAAM,OAAO,MAAM,MAAM,CAAC;AAC7E,YAAM,UAAU,YAAY,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,UAAI,CAAC,YAAY,uBAAuB;AACtC,wBAAgB;AAChB,YAAI,eAAe;AACjB,yBAAe,WAAW,OAAO;AAAA,QACnC;AAAA,MACF;AACA,6BAAuB,MAAM,EAAE,OAAO;AAEtC,UAAI;AACF,YAAI,YAAY,IAAI,IAAI,wBAAwB,YAAY,iCAAiC;AAC3F,gBAAM,2BAA2B;AACjC,kCAAwB,YAAY,IAAI;AAAA,QAC1C;AACA,cAAM,YAAY,YAAY,IAAI;AAAA,MACpC,SAAS,OAAO;AACd,gBAAQ,MAAM,yBAAyB,IAAI;AAC3C,YAAI,CAAC,YAAY,uBAAuB;AACtC,gBAAM,IAAI,sBAAsB;AAAA,YAC9B,OAAO;AAAA,YACP,SAAS;AAAA,YACT;AAAA,UACF,CAAC;AAAA,QACH;AAEA;AAAA,UACE,IAAI,sBAAsB;AAAA,YACxB,OAAO;AAAA,YACP,SAAS;AAAA,YACT;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AACA,oBAAc;AACd,kCAA4B;AAAA,IAC9B;AACA,QAAI,eAAe;AACjB,YAAM;AAAA,IACR;AAAA,EACF,UAAE;AAIA,mBAAe,QAAQ;AAAA,EACzB;AAEA,WAAS,2BAA6C;AACpD,UAAM,WAAW,eAAe;AAChC,8BAA0B,SAAS,UAAU,GAAG,YAAY,gBAAgB;AAC5E,aAAS,OAAO,aAAa;AAC7B,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/lib/esm/markdown-code-block-processor-registrar.d.mts

@@ -55,6 +55,13 @@ export declare class PluginMarkdownCodeBlockProcessorRegistrar implements Markdo
     /**
      * Registers a markdown code block processor.
      *
+     * Does nothing, and returns a no-op processor, when the plugin instance is not loaded. Obsidian `1.15.1`'s
+     * `Component.register` keeps a cleanup handed to an unloaded component without ever running it, so a processor
+     * registered by an instance that was unloaded while it was still loading (a plugin update, an install over an
+     * existing copy, a Hot Reload) would stay in Obsidian's global language map for the rest of the session, and the
+     * next instance's registration of the same language would throw `Code block postprocessor for language ... is
+     * already registered`.
+     *
      * @param params - The parameters for the markdown code block processor.
      * @returns The markdown post processor.
      */

package/dist/lib/esm/markdown-code-block-processor-registrar.mjs

@@ -31,6 +31,8 @@ ensureBrowserProcess();
 })();
 
 import { normalizePromisable } from "@mnaoumov/typescript-lib/async";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { getObsidianLibDebugger } from "./debug.mjs";
 class PluginMarkdownCodeBlockProcessorRegistrar {
   /**
    * The Obsidian plugin instance the code block processors are registered with.
@@ -47,14 +49,27 @@ class PluginMarkdownCodeBlockProcessorRegistrar {
   /**
    * Registers a markdown code block processor.
    *
+   * Does nothing, and returns a no-op processor, when the plugin instance is not loaded. Obsidian `1.15.1`'s
+   * `Component.register` keeps a cleanup handed to an unloaded component without ever running it, so a processor
+   * registered by an instance that was unloaded while it was still loading (a plugin update, an install over an
+   * existing copy, a Hot Reload) would stay in Obsidian's global language map for the rest of the session, and the
+   * next instance's registration of the same language would throw `Code block postprocessor for language ... is
+   * already registered`.
+   *
    * @param params - The parameters for the markdown code block processor.
    * @returns The markdown post processor.
    */
   registerMarkdownCodeBlockProcessor(params) {
+    if (!this.plugin._loaded) {
+      getObsidianLibDebugger("PluginMarkdownCodeBlockProcessorRegistrar")(
+        `Skipped registering the code block processor for language ${params.language}: the plugin instance is not loaded.`
+      );
+      return noop;
+    }
     return this.plugin.registerMarkdownCodeBlockProcessor(params.language, (source, element, context) => normalizePromisable(params.handler(source, element, context)), params.sortOrder);
   }
 }
 export {
   PluginMarkdownCodeBlockProcessorRegistrar
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/markdown-view.d.mts

@@ -1,10 +1,34 @@
 /// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
 /**
  * @file
  *
  * Utilities for working with MarkdownView
  */
-import type { MarkdownView } from 'obsidian';
+import type { App } from 'obsidian';
+import { MarkdownView } from 'obsidian';
+/**
+ * Options for {@link rerenderPreviews}.
+ */
+export interface RerenderPreviewsParams {
+    /**
+     * Stops waiting for the renders when aborted, rejecting with the signal's reason. The renders already requested still
+     * happen.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * The Obsidian app.
+     */
+    readonly app: App;
+    /**
+     * The code block language whose blocks to render again, matched exactly and case-sensitively, the way Obsidian matches a
+     * code block processor's language. Only the sections holding such a block are rendered again, and a view holding none
+     * is left alone.
+     *
+     * @default `null`, which renders every section of every Reading view again
+     */
+    readonly language?: null | string;
+}
 /**
  * Get the full HTML content of the current MarkdownView
  *
@@ -12,3 +36,26 @@ import type { MarkdownView } from 'obsidian';
  * @returns The full HTML of the MarkdownView
  */
 export declare function getFullContentHtml(view: MarkdownView): string;
+/**
+ * Renders the open Reading views again, so a markdown post-processor or code block processor registered or reconfigured
+ * since they rendered applies to them.
+ *
+ * It covers every Markdown view in every window, popouts included. A full refresh is what Obsidian itself does when a
+ * post-processor is registered: every section is rendered again, except the header holding the inline title and the
+ * properties, and the footer holding the backlinks, which keep their DOM. With a `language`, only the sections holding a
+ * code block of that language are rendered again. The note is never written, the view mode never changes, and the
+ * scroll position is kept by Obsidian's renderer.
+ *
+ * The promise settles once every view SHOWN in Reading view has finished rendering, the promises of asynchronous
+ * post-processors included. A preview that is not shown (a background tab, a view in editing mode) is marked to render
+ * again when it is next shown, and is not waited for, since Obsidian does not render it until then. A view that is closed,
+ * hidden or switched out of Reading view while rendering stops being waited for. A post-processor whose promise never
+ * settles, or rejects, keeps its view's render open, exactly as it keeps Obsidian's own render open; pass an
+ * `abortSignal` to bound the wait.
+ *
+ * Hover popovers, embeds, canvas cards and Live Preview widgets are not refreshed.
+ *
+ * @param params - The options.
+ * @returns A promise that resolves once the shown Reading views have rendered.
+ */
+export declare function rerenderPreviews(params: RerenderPreviewsParams): Promise<void>;

package/dist/lib/esm/markdown-view.mjs

@@ -2,7 +2,91 @@
 THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
 
+ensureDisposeSymbols();
+ensureBrowserProcess();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { onAbort } from "@mnaoumov/typescript-lib/abort-controller";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import {
+  Component,
+  MarkdownView
+} from "obsidian";
 function getFullContentHtml(view) {
   const codeMirror = view.editor.cm;
   codeMirror.viewState.printing = true;
@@ -12,7 +96,113 @@ function getFullContentHtml(view) {
   codeMirror.measure();
   return html;
 }
+async function rerenderPreviews(params) {
+  var _stack = [];
+  try {
+    const { abortSignal, app, language = null } = params;
+    abortSignal?.throwIfAborted();
+    const views = [];
+    app.workspace.iterateAllLeaves((leaf) => {
+      if (leaf.view instanceof MarkdownView) {
+        views.push(leaf.view);
+      }
+    });
+    const waits = [];
+    for (const view of views) {
+      const isShown = isPreviewShown(view);
+      const scroll = isShown ? view.previewMode.getScroll() : null;
+      if (language === null) {
+        view.previewMode.rerender(true);
+      } else {
+        const sections = getSectionsWithLanguage(view.previewMode, language);
+        if (sections.length === 0) {
+          continue;
+        }
+        rerenderSections(view.previewMode, sections);
+      }
+      if (scroll !== null) {
+        waits.push(waitForPreviewRender(app, view, scroll));
+      }
+    }
+    if (waits.length === 0) {
+      return;
+    }
+    const allRendered = Promise.all(waits);
+    if (!abortSignal) {
+      await allRendered;
+      return;
+    }
+    let resolveAborted = noop;
+    const aborted = new Promise((resolve) => {
+      resolveAborted = resolve;
+    });
+    const _abortListener = __using(_stack, onAbort(abortSignal, () => {
+      resolveAborted();
+    }));
+    await Promise.race([allRendered, aborted]);
+    abortSignal.throwIfAborted();
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function getSectionsWithLanguage(previewMode, language) {
+  const { renderer } = previewMode;
+  const selector = `code.language-${CSS.escape(language)}`;
+  const parser = new DOMParser();
+  return renderer.sections.filter(
+    (section) => section !== renderer.header && section !== renderer.footer && !!section.html && parser.parseFromString(section.html, "text/html").querySelector(selector) !== null
+  );
+}
+function isPreviewShown(view) {
+  if (view.getMode() !== "preview") {
+    return false;
+  }
+  const { previewEl } = view.previewMode.renderer;
+  return previewEl.isConnected && previewEl.offsetParent !== null && previewEl.offsetWidth > 0;
+}
+function rerenderSections(previewMode, sections) {
+  for (const section of sections) {
+    section.rendered = false;
+    section.el.empty();
+  }
+  previewMode.renderer.queueRender();
+}
+async function waitForPreviewRender(app, view, scroll) {
+  const { previewMode } = view;
+  const isRendered = await new Promise((resolve) => {
+    let isSettled = false;
+    const watcher = new Component();
+    function settle(isRenderedNow) {
+      if (isSettled) {
+        return;
+      }
+      isSettled = true;
+      previewMode.removeChild(watcher);
+      resolve(isRenderedNow);
+    }
+    function settleIfHidden() {
+      if (!isPreviewShown(view)) {
+        settle(false);
+      }
+    }
+    watcher.register(() => {
+      settle(false);
+    });
+    watcher.registerEvent(app.workspace.on("layout-change", settleIfHidden));
+    watcher.registerEvent(app.workspace.on("active-leaf-change", settleIfHidden));
+    previewMode.addChild(watcher);
+    previewMode.renderer.onRendered(() => {
+      settle(true);
+    });
+  });
+  if (isRendered) {
+    previewMode.applyScroll(scroll);
+  }
+}
 export {
-  getFullContentHtml
+  getFullContentHtml,
+  rerenderPreviews
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL21hcmtkb3duLXZpZXcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBVdGlsaXRpZXMgZm9yIHdvcmtpbmcgd2l0aCBNYXJrZG93blZpZXdcbiAqL1xuXG5pbXBvcnQgdHlwZSB7IE1hcmtkb3duVmlldyB9IGZyb20gJ29ic2lkaWFuJztcblxuLyoqXG4gKiBHZXQgdGhlIGZ1bGwgSFRNTCBjb250ZW50IG9mIHRoZSBjdXJyZW50IE1hcmtkb3duVmlld1xuICpcbiAqIEBwYXJhbSB2aWV3IC0gVGhlIE1hcmtkb3duVmlldyB0byBnZXQgdGhlIEhUTUwgZnJvbVxuICogQHJldHVybnMgVGhlIGZ1bGwgSFRNTCBvZiB0aGUgTWFya2Rvd25WaWV3XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRGdWxsQ29udGVudEh0bWwodmlldzogTWFya2Rvd25WaWV3KTogc3RyaW5nIHtcbiAgY29uc3QgY29kZU1pcnJvciA9IHZpZXcuZWRpdG9yLmNtO1xuICBjb2RlTWlycm9yLnZpZXdTdGF0ZS5wcmludGluZyA9IHRydWU7XG4gIGNvZGVNaXJyb3IubWVhc3VyZSgpO1xuICBjb25zdCBodG1sID0gdmlldy5jb250ZW50RWwuaW5uZXJIVE1MO1xuICBjb2RlTWlycm9yLnZpZXdTdGF0ZS5wcmludGluZyA9IGZhbHNlO1xuICBjb2RlTWlycm9yLm1lYXN1cmUoKTtcbiAgcmV0dXJuIGh0bWw7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQWNPLFNBQVMsbUJBQW1CLE1BQTRCO0FBQzdELFFBQU0sYUFBYSxLQUFLLE9BQU87QUFDL0IsYUFBVyxVQUFVLFdBQVc7QUFDaEMsYUFBVyxRQUFRO0FBQ25CLFFBQU0sT0FBTyxLQUFLLFVBQVU7QUFDNUIsYUFBVyxVQUFVLFdBQVc7QUFDaEMsYUFBVyxRQUFRO0FBQ25CLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/markdown-view.ts"],"sourcesContent":["/**\n * @file\n *\n * Utilities for working with MarkdownView\n */\n\nimport type { RendererSection } from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  MarkdownPreviewView\n} from 'obsidian';\n\nimport { onAbort } from '@mnaoumov/typescript-lib/abort-controller';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport {\n  Component,\n  MarkdownView\n} from 'obsidian';\n\n/**\n * Options for {@link rerenderPreviews}.\n */\nexport interface RerenderPreviewsParams {\n  /**\n   * Stops waiting for the renders when aborted, rejecting with the signal's reason. The renders already requested still\n   * happen.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The Obsidian app.\n   */\n  readonly app: App;\n\n  /**\n   * The code block language whose blocks to render again, matched exactly and case-sensitively, the way Obsidian matches a\n   * code block processor's language. Only the sections holding such a block are rendered again, and a view holding none\n   * is left alone.\n   *\n   * @default `null`, which renders every section of every Reading view again\n   */\n  readonly language?: null | string;\n}\n\n/**\n * Get the full HTML content of the current MarkdownView\n *\n * @param view - The MarkdownView to get the HTML from\n * @returns The full HTML of the MarkdownView\n */\nexport function getFullContentHtml(view: MarkdownView): string {\n  const codeMirror = view.editor.cm;\n  codeMirror.viewState.printing = true;\n  codeMirror.measure();\n  const html = view.contentEl.innerHTML;\n  codeMirror.viewState.printing = false;\n  codeMirror.measure();\n  return html;\n}\n\n/**\n * Renders the open Reading views again, so a markdown post-processor or code block processor registered or reconfigured\n * since they rendered applies to them.\n *\n * It covers every Markdown view in every window, popouts included. A full refresh is what Obsidian itself does when a\n * post-processor is registered: every section is rendered again, except the header holding the inline title and the\n * properties, and the footer holding the backlinks, which keep their DOM. With a `language`, only the sections holding a\n * code block of that language are rendered again. The note is never written, the view mode never changes, and the\n * scroll position is kept by Obsidian's renderer.\n *\n * The promise settles once every view SHOWN in Reading view has finished rendering, the promises of asynchronous\n * post-processors included. A preview that is not shown (a background tab, a view in editing mode) is marked to render\n * again when it is next shown, and is not waited for, since Obsidian does not render it until then. A view that is closed,\n * hidden or switched out of Reading view while rendering stops being waited for. A post-processor whose promise never\n * settles, or rejects, keeps its view's render open, exactly as it keeps Obsidian's own render open; pass an\n * `abortSignal` to bound the wait.\n *\n * Hover popovers, embeds, canvas cards and Live Preview widgets are not refreshed.\n *\n * @param params - The options.\n * @returns A promise that resolves once the shown Reading views have rendered.\n */\nexport async function rerenderPreviews(params: RerenderPreviewsParams): Promise<void> {\n  const { abortSignal, app, language = null } = params;\n  abortSignal?.throwIfAborted();\n\n  const views: MarkdownView[] = [];\n  app.workspace.iterateAllLeaves((leaf) => {\n    if (leaf.view instanceof MarkdownView) {\n      views.push(leaf.view);\n    }\n  });\n\n  const waits: Promise<void>[] = [];\n  for (const view of views) {\n    const isShown = isPreviewShown(view);\n    // Emptying the sections shrinks the content before the next frame renders it again, which can clamp the scroll.\n    const scroll = isShown ? view.previewMode.getScroll() : null;\n    if (language === null) {\n      view.previewMode.rerender(true);\n    } else {\n      const sections = getSectionsWithLanguage(view.previewMode, language);\n      if (sections.length === 0) {\n        continue;\n      }\n      rerenderSections(view.previewMode, sections);\n    }\n\n    if (scroll !== null) {\n      waits.push(waitForPreviewRender(app, view, scroll));\n    }\n  }\n\n  if (waits.length === 0) {\n    return;\n  }\n\n  const allRendered = Promise.all(waits);\n  if (!abortSignal) {\n    await allRendered;\n    return;\n  }\n\n  let resolveAborted = noop;\n  const aborted = new Promise<void>((resolve) => {\n    resolveAborted = resolve;\n  });\n  using _abortListener = onAbort(abortSignal, () => {\n    resolveAborted();\n  });\n  await Promise.race([allRendered, aborted]);\n  abortSignal.throwIfAborted();\n}\n\nfunction getSectionsWithLanguage(previewMode: MarkdownPreviewView, language: string): RendererSection[] {\n  const { renderer } = previewMode;\n  const selector = `code.language-${CSS.escape(language)}`;\n  const parser = new DOMParser();\n  // The header and footer carry no HTML of their own. A section's HTML is parsed into an inert document: nothing runs\n  // and nothing loads.\n  return renderer.sections.filter((section) =>\n    section !== renderer.header && section !== renderer.footer && !!section.html\n    && parser.parseFromString(section.html, 'text/html').querySelector(selector) !== null\n  );\n}\n\nfunction isPreviewShown(view: MarkdownView): boolean {\n  if (view.getMode() !== 'preview') {\n    return false;\n  }\n\n  // The same visibility test `ReadViewRenderer.onRender` makes before it renders anything.\n  const { previewEl } = view.previewMode.renderer;\n  return previewEl.isConnected && previewEl.offsetParent !== null && previewEl.offsetWidth > 0;\n}\n\nfunction rerenderSections(previewMode: MarkdownPreviewView, sections: readonly RendererSection[]): void {\n  for (const section of sections) {\n    section.rendered = false;\n    section.el.empty();\n  }\n  previewMode.renderer.queueRender();\n}\n\nasync function waitForPreviewRender(app: App, view: MarkdownView, scroll: number): Promise<void> {\n  const { previewMode } = view;\n  const isRendered = await new Promise<boolean>((resolve) => {\n    let isSettled = false;\n    const watcher = new Component();\n\n    function settle(isRenderedNow: boolean): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      // A no-op when the preview is unloading, since it has already taken the watcher off its children.\n      previewMode.removeChild(watcher);\n      resolve(isRenderedNow);\n    }\n\n    function settleIfHidden(): void {\n      if (!isPreviewShown(view)) {\n        settle(false);\n      }\n    }\n\n    watcher.register(() => {\n      settle(false);\n    });\n    watcher.registerEvent(app.workspace.on('layout-change', settleIfHidden));\n    watcher.registerEvent(app.workspace.on('active-leaf-change', settleIfHidden));\n    previewMode.addChild(watcher);\n    previewMode.renderer.onRendered(() => {\n      settle(true);\n    });\n  });\n\n  if (isRendered) {\n    previewMode.applyScroll(scroll);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/metadata-cache.d.mts

@@ -5,6 +5,7 @@
  * This module provides utility functions for working with the metadata cache in Obsidian.
  */
 import type { RetryOptions } from '@mnaoumov/typescript-lib/async';
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
 import type { CustomArrayDict } from '@obsidian-typings/obsidian-public-latest';
 import type { App, CachedMetadata, Reference, TAbstractFile } from 'obsidian';
 import type { PathOrFile } from './file-system.mjs';
@@ -322,17 +323,17 @@ export declare function parseMetadata(app: App, $string: string, options?: Parse
  * Registers the file cache for a non-existing file.
  *
  * @param params - The parameters for registering the file cache.
- * @returns A {@link Disposable} that unregisters the file cache when disposed, for use with `using`.
+ * @returns A {@link DisposableEx} that unregisters the file cache when disposed, for use with `using`.
  */
-export declare function registerFileCacheForNonExistingFile(params: RegisterFileCacheForNonExistingFileParams): Disposable;
+export declare function registerFileCacheForNonExistingFile(params: RegisterFileCacheForNonExistingFileParams): DisposableEx;
 /**
  * Registers files in the Obsidian app.
  *
  * @param app - The Obsidian app instance.
  * @param files - The files to register.
- * @returns A {@link Disposable} that unregisters the files when disposed, for use with `using`.
+ * @returns A {@link DisposableEx} that unregisters the files when disposed, for use with `using`.
  */
-export declare function registerFiles(app: App, files: TAbstractFile[]): Disposable;
+export declare function registerFiles(app: App, files: TAbstractFile[]): DisposableEx;
 /**
  * Unregisters the file cache for a non-existing file.
  *