obsidian-dev-utils 74.0.0 → 74.1.0

package/dist/lib/cjs/obsidian/constructors/getDomEventsHandlersConstructor.cjs

@@ -178,6 +178,22 @@ var import_async = require('../../async.cjs');
 var import_type_guards = require('../../type-guards.cjs');
 var import_monkey_around_component = require('../components/monkey-around-component.cjs');
 var import_vault = require('../vault.cjs');
+class MarkdownPreviewRendererRegisterDomEventsPatchComponent extends import_monkey_around_component.MonkeyAroundComponent {
+  domEventsHandlersConstructor = null;
+  onload() {
+    this.registerMethodPatch({
+      methodName: "registerDomEvents",
+      obj: import_obsidian.MarkdownPreviewRenderer,
+      patchHandler: ({
+        fallback,
+        originalArgs: [, handlers]
+      }) => {
+        this.domEventsHandlersConstructor = handlers.constructor;
+        fallback();
+      }
+    });
+  }
+}
 async function getDomEventsHandlersConstructor(app) {
   let mdFile = app.vault.getMarkdownFiles()[0];
   let shouldDelete = false;
@@ -185,23 +201,11 @@ async function getDomEventsHandlersConstructor(app) {
     mdFile = await app.vault.create("__temp.md", "");
     shouldDelete = true;
   }
-  let ctor = null;
   try {
     var _stack = [];
     try {
-      const patch = __using(_stack, new import_monkey_around_component.MonkeyAroundComponent());
+      const patch = __using(_stack, new MarkdownPreviewRendererRegisterDomEventsPatchComponent());
       patch.load();
-      patch.registerMethodPatch({
-        methodName: "registerDomEvents",
-        obj: import_obsidian.MarkdownPreviewRenderer,
-        patchHandler({
-          fallback,
-          originalArgs: [, handlers]
-        }) {
-          ctor = handlers.constructor;
-          fallback();
-        }
-      });
       const leaf = app.workspace.getLeaf(true);
       await leaf.openFile(mdFile, {
         active: true,
@@ -209,14 +213,14 @@ async function getDomEventsHandlersConstructor(app) {
       });
       try {
         await (0, import_async.retryWithTimeout)({
-          operationFn: () => ctor !== null,
+          operationFn: () => patch.domEventsHandlersConstructor !== null,
           operationName: "getDomEventsHandlersConstructor"
         });
       } finally {
         leaf.detach();
       }
-      (0, import_type_guards.assertNonNullable)(ctor, "Failed to get register dom events handlers constructor");
-      return ctor;
+      (0, import_type_guards.assertNonNullable)(patch.domEventsHandlersConstructor, "Failed to get register dom events handlers constructor");
+      return patch.domEventsHandlersConstructor;
     } catch (_) {
       var _error = _, _hasError = true;
     } finally {
@@ -232,4 +236,4 @@ async function getDomEventsHandlersConstructor(app) {
 0 && (module.exports = {
   getDomEventsHandlersConstructor
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbnN0cnVjdG9ycy9nZXREb21FdmVudHNIYW5kbGVyc0NvbnN0cnVjdG9yLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogVGhpcyBtb2R1bGUgZXh0cmFjdHMgdGhlIGBEb21FdmVudHNIYW5kbGVyc0NvbnN0cnVjdG9yYCBmcm9tIE9ic2lkaWFuJ3MgcnVudGltZVxuICogYnkgdGVtcG9yYXJpbHkgb3BlbmluZyBhIG1hcmtkb3duIGZpbGUgaW4gcHJldmlldyBtb2RlIGFuZCBpbnRlcmNlcHRpbmcgdGhlXG4gKiBjb25zdHJ1Y3RvciBwYXNzZWQgdG8gYE1hcmtkb3duUHJldmlld1JlbmRlcmVyLnJlZ2lzdGVyRG9tRXZlbnRzYC5cbiAqL1xuXG4vKiB2OCBpZ25vcmUgc3RhcnQgLS0gRGVlcGx5IGNvdXBsZWQgdG8gT2JzaWRpYW4gcnVudGltZTsgcmVxdWlyZXMgcnVubmluZyB2YXVsdCBmb3IgbWVhbmluZ2Z1bCB0ZXN0aW5nLiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIERvbUV2ZW50c0hhbmRsZXJzLFxuICBFeHRyYWN0Q29uc3RydWN0b3Jcbn0gZnJvbSAnQG9ic2lkaWFuLXR5cGluZ3Mvb2JzaWRpYW4tcHVibGljLWxhdGVzdCc7XG5pbXBvcnQgdHlwZSB7IEFwcCB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgTWFya2Rvd25QcmV2aWV3UmVuZGVyZXIgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB7IHJldHJ5V2l0aFRpbWVvdXQgfSBmcm9tICcuLi8uLi9hc3luYy50cyc7XG5pbXBvcnQgeyBhc3NlcnROb25OdWxsYWJsZSB9IGZyb20gJy4uLy4uL3R5cGUtZ3VhcmRzLnRzJztcbmltcG9ydCB7IE1vbmtleUFyb3VuZENvbXBvbmVudCB9IGZyb20gJy4uL2NvbXBvbmVudHMvbW9ua2V5LWFyb3VuZC1jb21wb25lbnQudHMnO1xuaW1wb3J0IHsgdHJhc2hTYWZlIH0gZnJvbSAnLi4vdmF1bHQudHMnO1xuXG50eXBlIERvbUV2ZW50c0hhbmRsZXJzQ29uc3RydWN0b3IgPSBFeHRyYWN0Q29uc3RydWN0b3I8RG9tRXZlbnRzSGFuZGxlcnM+O1xuXG5jbGFzcyBNYXJrZG93blByZXZpZXdSZW5kZXJlclJlZ2lzdGVyRG9tRXZlbnRzUGF0Y2hDb21wb25lbnQgZXh0ZW5kcyBNb25rZXlBcm91bmRDb21wb25lbnQge1xuICBwdWJsaWMgZG9tRXZlbnRzSGFuZGxlcnNDb25zdHJ1Y3RvcjogRG9tRXZlbnRzSGFuZGxlcnNDb25zdHJ1Y3RvciB8IG51bGwgPSBudWxsO1xuXG4gIHB1YmxpYyBvdmVycmlkZSBvbmxvYWQoKTogdm9pZCB7XG4gICAgdGhpcy5yZWdpc3Rlck1ldGhvZFBhdGNoKHtcbiAgICAgIG1ldGhvZE5hbWU6ICdyZWdpc3RlckRvbUV2ZW50cycsXG4gICAgICBvYmo6IE1hcmtkb3duUHJldmlld1JlbmRlcmVyLFxuICAgICAgcGF0Y2hIYW5kbGVyOiAoe1xuICAgICAgICBmYWxsYmFjayxcbiAgICAgICAgb3JpZ2luYWxBcmdzOiBbLCBoYW5kbGVyc11cbiAgICAgIH0pID0+IHtcbiAgICAgICAgdGhpcy5kb21FdmVudHNIYW5kbGVyc0NvbnN0cnVjdG9yID0gaGFuZGxlcnMuY29uc3RydWN0b3IgYXMgRG9tRXZlbnRzSGFuZGxlcnNDb25zdHJ1Y3RvcjtcbiAgICAgICAgZmFsbGJhY2soKTtcbiAgICAgIH1cbiAgICB9KTtcbiAgfVxufVxuXG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuXG4vKipcbiAqIEV4dHJhY3RzIHRoZSBgRG9tRXZlbnRzSGFuZGxlcnNDb25zdHJ1Y3RvcmAgZnJvbSBPYnNpZGlhbidzIHJ1bnRpbWUuXG4gKlxuICogT3BlbnMgYSB0ZW1wb3JhcnkgbWFya2Rvd24gZmlsZSBpbiBwcmV2aWV3IG1vZGUgYW5kIGludGVyY2VwdHMgdGhlIGNvbnN0cnVjdG9yXG4gKiBwYXNzZWQgdG8gYE1hcmtkb3duUHJldmlld1JlbmRlcmVyLnJlZ2lzdGVyRG9tRXZlbnRzYC5cbiAqXG4gKiBAcGFyYW0gYXBwIC0gVGhlIE9ic2lkaWFuIGFwcCBpbnN0YW5jZS5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gdGhlIGBEb21FdmVudHNIYW5kbGVyc0NvbnN0cnVjdG9yYC5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdldERvbUV2ZW50c0hhbmRsZXJzQ29uc3RydWN0b3IoYXBwOiBBcHApOiBQcm9taXNlPERvbUV2ZW50c0hhbmRsZXJzQ29uc3RydWN0b3I+IHtcbiAgbGV0IG1kRmlsZSA9IGFwcC52YXVsdC5nZXRNYXJrZG93bkZpbGVzKClbMF07XG4gIGxldCBzaG91bGREZWxldGUgPSBmYWxzZTtcbiAgaWYgKCFtZEZpbGUpIHtcbiAgICBtZEZpbGUgPSBhd2FpdCBhcHAudmF1bHQuY3JlYXRlKCdfX3RlbXAubWQnLCAnJyk7XG4gICAgc2hvdWxkRGVsZXRlID0gdHJ1ZTtcbiAgfVxuICB0cnkge1xuICAgIHVzaW5nIHBhdGNoID0gbmV3IE1hcmtkb3duUHJldmlld1JlbmRlcmVyUmVnaXN0ZXJEb21FdmVudHNQYXRjaENvbXBvbmVudCgpO1xuICAgIHBhdGNoLmxvYWQoKTtcblxuICAgIGNvbnN0IGxlYWYgPSBhcHAud29ya3NwYWNlLmdldExlYWYodHJ1ZSk7XG4gICAgYXdhaXQgbGVhZi5vcGVuRmlsZShtZEZpbGUsIHtcbiAgICAgIGFjdGl2ZTogdHJ1ZSxcbiAgICAgIHN0YXRlOiB7IG1vZGU6ICdwcmV2aWV3JyB9XG4gICAgfSk7XG4gICAgdHJ5IHtcbiAgICAgIGF3YWl0IHJldHJ5V2l0aFRpbWVvdXQoe1xuICAgICAgICBvcGVyYXRpb25GbjogKCkgPT4gcGF0Y2guZG9tRXZlbnRzSGFuZGxlcnNDb25zdHJ1Y3RvciAhPT0gbnVsbCxcbiAgICAgICAgb3BlcmF0aW9uTmFtZTogJ2dldERvbUV2ZW50c0hhbmRsZXJzQ29uc3RydWN0b3InXG4gICAgICB9KTtcbiAgICB9IGZpbmFsbHkge1xuICAgICAgbGVhZi5kZXRhY2goKTtcbiAgICB9XG5cbiAgICBhc3NlcnROb25OdWxsYWJsZShwYXRjaC5kb21FdmVudHNIYW5kbGVyc0NvbnN0cnVjdG9yLCAnRmFpbGVkIHRvIGdldCByZWdpc3RlciBkb20gZXZlbnRzIGhhbmRsZXJzIGNvbnN0cnVjdG9yJyk7XG4gICAgcmV0dXJuIHBhdGNoLmRvbUV2ZW50c0hhbmRsZXJzQ29uc3RydWN0b3I7XG4gIH0gZmluYWxseSB7XG4gICAgaWYgKHNob3VsZERlbGV0ZSkge1xuICAgICAgYXdhaXQgdHJhc2hTYWZlKGFwcCwgbWRGaWxlKTtcbiAgICB9XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQWdCQSxzQkFBd0M7QUFFeEMsbUJBQWlDO0FBQ2pDLHlCQUFrQztBQUNsQyxxQ0FBc0M7QUFDdEMsbUJBQTBCO0FBSTFCLE1BQU0sK0RBQStELHFEQUFzQjtBQUFBLEVBQ2xGLCtCQUFvRTtBQUFBLEVBRTNELFNBQWU7QUFDN0IsU0FBSyxvQkFBb0I7QUFBQSxNQUN2QixZQUFZO0FBQUEsTUFDWixLQUFLO0FBQUEsTUFDTCxjQUFjLENBQUM7QUFBQSxRQUNiO0FBQUEsUUFDQSxjQUFjLENBQUMsRUFBRSxRQUFRO0FBQUEsTUFDM0IsTUFBTTtBQUNKLGFBQUssK0JBQStCLFNBQVM7QUFDN0MsaUJBQVM7QUFBQSxNQUNYO0FBQUEsSUFDRixDQUFDO0FBQUEsRUFDSDtBQUNGO0FBYUEsZUFBc0IsZ0NBQWdDLEtBQWlEO0FBQ3JHLE1BQUksU0FBUyxJQUFJLE1BQU0saUJBQWlCLEVBQUUsQ0FBQztBQUMzQyxNQUFJLGVBQWU7QUFDbkIsTUFBSSxDQUFDLFFBQVE7QUFDWCxhQUFTLE1BQU0sSUFBSSxNQUFNLE9BQU8sYUFBYSxFQUFFO0FBQy9DLG1CQUFlO0FBQUEsRUFDakI7QUFDQSxNQUFJO0FBQ0Y7QUFBQTtBQUFBLFlBQU0sUUFBUSxvQkFBSSx1REFBdUQ7QUFDekUsWUFBTSxLQUFLO0FBRVgsWUFBTSxPQUFPLElBQUksVUFBVSxRQUFRLElBQUk7QUFDdkMsWUFBTSxLQUFLLFNBQVMsUUFBUTtBQUFBLFFBQzFCLFFBQVE7QUFBQSxRQUNSLE9BQU8sRUFBRSxNQUFNLFVBQVU7QUFBQSxNQUMzQixDQUFDO0FBQ0QsVUFBSTtBQUNGLGtCQUFNLCtCQUFpQjtBQUFBLFVBQ3JCLGFBQWEsTUFBTSxNQUFNLGlDQUFpQztBQUFBLFVBQzFELGVBQWU7QUFBQSxRQUNqQixDQUFDO0FBQUEsTUFDSCxVQUFFO0FBQ0EsYUFBSyxPQUFPO0FBQUEsTUFDZDtBQUVBLGdEQUFrQixNQUFNLDhCQUE4Qix3REFBd0Q7QUFDOUcsYUFBTyxNQUFNO0FBQUEsYUFsQmI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBbUJGLFVBQUU7QUFDQSxRQUFJLGNBQWM7QUFDaEIsZ0JBQU0sd0JBQVUsS0FBSyxNQUFNO0FBQUEsSUFDN0I7QUFBQSxFQUNGO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/cjs/obsidian/markdown.cjs

@@ -184,6 +184,26 @@ var import_monkey_around_component = require('./components/monkey-around-compone
 var import_getDomEventsHandlersConstructor = require('./constructors/getDomEventsHandlersConstructor.cjs');
 var import_file_system = require('./file-system.cjs');
 let domEventsHandlersConstructor = null;
+class EmbedByExtensionMdPatchComponent extends import_monkey_around_component.MonkeyAroundComponent {
+  constructor(embedByExtension) {
+    super();
+    this.embedByExtension = embedByExtension;
+  }
+  embedByExtension;
+  onload() {
+    this.registerMethodPatch({
+      methodName: "md",
+      obj: this.embedByExtension,
+      patchHandler: ({
+        fallback,
+        originalArgs: [context]
+      }) => {
+        context.displayMode = false;
+        return fallback();
+      }
+    });
+  }
+}
 class FixedZIndexDomEventsHandlersInfo {
   app;
   el;
@@ -230,18 +250,7 @@ async function fullRender(params) {
       component.load();
       shouldUnloadComponent = true;
     }
-    const patch = __using(_stack, component.addChild(new import_monkey_around_component.MonkeyAroundComponent()));
-    patch.registerMethodPatch({
-      methodName: "md",
-      obj: params.app.embedRegistry.embedByExtension,
-      patchHandler: ({
-        fallback,
-        originalArgs: [context]
-      }) => {
-        context.displayMode = false;
-        return fallback();
-      }
-    });
+    const _ = __using(_stack, component.addChild(new EmbedByExtensionMdPatchComponent(params.app.embedRegistry.embedByExtension)));
     await import_obsidian.MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);
     if (shouldUnloadComponent) {
       component.unload();
@@ -249,8 +258,8 @@ async function fullRender(params) {
     if (params.shouldRegisterLinkHandlers) {
       await registerLinkHandlers(params.app, params.el, params.sourcePath);
     }
-  } catch (_) {
-    var _error = _, _hasError = true;
+  } catch (_2) {
+    var _error = _2, _hasError = true;
   } finally {
     __callDispose(_stack, _error, _hasError);
   }
@@ -319,4 +328,4 @@ async function renderInternalLink(app, pathOrAbstractFile, displayText) {
   renderExternalLink,
   renderInternalLink
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/markdown.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for processing Markdown content in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  DomEventsHandlers,\n  DomEventsHandlersInfo\n} from '@obsidian-typings/obsidian-public-latest';\nimport type { ExtractConstructor } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport type { App } from 'obsidian';\n\nimport { InternalPluginName } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  Component,\n  HoverPopover,\n  MarkdownPreviewRenderer,\n  MarkdownRenderer\n} from 'obsidian';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { getZIndex } from '../html-element.ts';\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { getDomEventsHandlersConstructor } from './constructors/getDomEventsHandlersConstructor.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath,\n  isFolder\n} from './file-system.ts';\n\ntype DomEventsHandlersConstructor = ExtractConstructor<DomEventsHandlers>;\n\nlet domEventsHandlersConstructor: DomEventsHandlersConstructor | null = null;\n\n/**\n * The params for the full render.\n */\nexport interface FullRenderParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The Component instance to use for the render.\n   */\n  readonly component?: Component;\n\n  /**\n   * The HTMLElement to render to.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The Markdown string to render.\n   */\n  readonly markdown: string;\n\n  /**\n   * Whether to register link handlers for the rendered element.\n   */\n  readonly shouldRegisterLinkHandlers?: boolean;\n\n  /**\n   * The source path to resolve relative links.\n   */\n  readonly sourcePath?: string;\n}\n\ninterface FixedZIndexDomEventsHandlersInfoConstructorParams {\n  readonly app: App;\n  readonly el: HTMLElement;\n  readonly path: string;\n}\n\nclass FixedZIndexDomEventsHandlersInfo implements DomEventsHandlersInfo {\n  public readonly app: App;\n  public readonly el: HTMLElement;\n  public readonly path: string;\n\n  public get hoverPopover(): HoverPopover | null {\n    return this._hoverPopover;\n  }\n\n  public set hoverPopover(hoverPopover: HoverPopover | null) {\n    this._hoverPopover = hoverPopover;\n    if (hoverPopover && this.zIndex !== undefined) {\n      hoverPopover.hoverEl.setCssStyles({\n        zIndex: String(this.zIndex)\n      });\n    }\n  }\n\n  private _hoverPopover: HoverPopover | null = null;\n\n  private zIndex?: number;\n\n  public constructor(params: FixedZIndexDomEventsHandlersInfoConstructorParams) {\n    this.app = params.app;\n    this.path = params.path;\n    this.el = params.el;\n\n    if (this.el.isConnected) {\n      this.updateZIndex(this.el);\n    } else {\n      this.el.onNodeInserted(() => {\n        this.updateZIndex(this.el);\n      });\n    }\n  }\n\n  private updateZIndex(el: HTMLElement): void {\n    this.zIndex = getZIndex(el) + 1;\n  }\n}\n\n/**\n * Render the markdown and embeds.\n *\n * @param params - The parameters for the full render.\n * @returns The {@link Promise} that resolves when the full render is complete.\n */\nexport async function fullRender(params: FullRenderParams): Promise<void> {\n  const sourcePath = params.sourcePath ?? '/';\n  let shouldUnloadComponent = false;\n  let component: Component;\n  if (params.component) {\n    component = params.component;\n  } else {\n    component = new Component();\n    component.load();\n    shouldUnloadComponent = true;\n  }\n\n  using patch = component.addChild(new MonkeyAroundComponent());\n\n  patch.registerMethodPatch({\n    methodName: 'md',\n    obj: params.app.embedRegistry.embedByExtension,\n    patchHandler: ({\n      fallback,\n      originalArgs: [context]\n    }) => {\n      context.displayMode = false;\n      return fallback();\n    }\n  });\n\n  await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);\n\n  if (shouldUnloadComponent) {\n    component.unload();\n  }\n\n  if (params.shouldRegisterLinkHandlers) {\n    await registerLinkHandlers(params.app, params.el, params.sourcePath);\n  }\n}\n\n/**\n * Converts Markdown to HTML.\n *\n * @param app - The Obsidian app instance.\n * @param markdown - The Markdown string to convert.\n * @param sourcePath - (optional) The source path to resolve relative links.\n * @returns The HTML string.\n */\nexport async function markdownToHtml(app: App, markdown: string, sourcePath?: string): Promise<string> {\n  const component = new Component();\n  component.load();\n  const renderDiv = createDiv();\n  await MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? '', component);\n  const html = renderDiv.innerHTML;\n  component.unload();\n  return html;\n}\n\n/**\n * Registers link handlers for the given element.\n *\n * @param app - The Obsidian app instance.\n * @param el - The HTMLElement to register link handlers for.\n * @param sourcePath - The source path to resolve relative links from.\n */\nexport async function registerLinkHandlers(app: App, el: HTMLElement, sourcePath?: string): Promise<void> {\n  // eslint-disable-next-line require-atomic-updates -- No race condition.\n  domEventsHandlersConstructor ??= await getDomEventsHandlersConstructor(app);\n  MarkdownPreviewRenderer.registerDomEvents(\n    el,\n    new domEventsHandlersConstructor(\n      new FixedZIndexDomEventsHandlersInfo({\n        app,\n        el,\n        path: sourcePath ?? ''\n      })\n    )\n  );\n}\n\n/**\n * Renders an external link.\n *\n * @param app - The Obsidian app instance.\n * @param url - The URL to render the external link for.\n * @param displayText - The text to display for the external link.\n * @returns The HTMLAnchorElement containing the rendered external link.\n */\nexport async function renderExternalLink(app: App, url: string, displayText?: string): Promise<HTMLAnchorElement> {\n  displayText ??= url;\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[${displayText}](${url})`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/**\n * Renders an internal link.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrAbstractFile - The path or abstract file to render the internal link for.\n * @param displayText - The text to display for the internal link.\n * @returns The HTMLAnchorElement containing the rendered internal link.\n */\nexport async function renderInternalLink(app: App, pathOrAbstractFile: PathOrAbstractFile, displayText?: string): Promise<HTMLAnchorElement> {\n  const abstractFile = getAbstractFileOrNull(app, pathOrAbstractFile);\n  const path = getPath(app, pathOrAbstractFile);\n  displayText ??= path;\n  if (isFolder(abstractFile)) {\n    return createEl('a', { text: displayText }, (aEl) => {\n      aEl.addEventListener('click', (evt) => {\n        evt.preventDefault();\n        app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer)?.revealInFolder(abstractFile);\n      });\n    });\n  }\n\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[[${path}|${displayText}]]`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["aEl"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/markdown.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for processing Markdown content in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  DomEventsHandlers,\n  DomEventsHandlersInfo,\n  EmbedRegistryEmbedByExtensionRecord\n} from '@obsidian-typings/obsidian-public-latest';\nimport type { ExtractConstructor } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport type { App } from 'obsidian';\n\nimport { InternalPluginName } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  Component,\n  HoverPopover,\n  MarkdownPreviewRenderer,\n  MarkdownRenderer\n} from 'obsidian';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { getZIndex } from '../html-element.ts';\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { getDomEventsHandlersConstructor } from './constructors/getDomEventsHandlersConstructor.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath,\n  isFolder\n} from './file-system.ts';\n\ntype DomEventsHandlersConstructor = ExtractConstructor<DomEventsHandlers>;\n\nlet domEventsHandlersConstructor: DomEventsHandlersConstructor | null = null;\n\n/**\n * The params for the full render.\n */\nexport interface FullRenderParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The Component instance to use for the render.\n   */\n  readonly component?: Component;\n\n  /**\n   * The HTMLElement to render to.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The Markdown string to render.\n   */\n  readonly markdown: string;\n\n  /**\n   * Whether to register link handlers for the rendered element.\n   */\n  readonly shouldRegisterLinkHandlers?: boolean;\n\n  /**\n   * The source path to resolve relative links.\n   */\n  readonly sourcePath?: string;\n}\n\ninterface FixedZIndexDomEventsHandlersInfoConstructorParams {\n  readonly app: App;\n  readonly el: HTMLElement;\n  readonly path: string;\n}\n\nclass EmbedByExtensionMdPatchComponent extends MonkeyAroundComponent {\n  public constructor(private readonly embedByExtension: EmbedRegistryEmbedByExtensionRecord) {\n    super();\n  }\n\n  public override onload(): void {\n    this.registerMethodPatch({\n      methodName: 'md',\n      obj: this.embedByExtension,\n      patchHandler: ({\n        fallback,\n        originalArgs: [context]\n      }) => {\n        context.displayMode = false;\n        return fallback();\n      }\n    });\n  }\n}\n\nclass FixedZIndexDomEventsHandlersInfo implements DomEventsHandlersInfo {\n  public readonly app: App;\n  public readonly el: HTMLElement;\n  public readonly path: string;\n\n  public get hoverPopover(): HoverPopover | null {\n    return this._hoverPopover;\n  }\n\n  public set hoverPopover(hoverPopover: HoverPopover | null) {\n    this._hoverPopover = hoverPopover;\n    if (hoverPopover && this.zIndex !== undefined) {\n      hoverPopover.hoverEl.setCssStyles({\n        zIndex: String(this.zIndex)\n      });\n    }\n  }\n\n  private _hoverPopover: HoverPopover | null = null;\n\n  private zIndex?: number;\n\n  public constructor(params: FixedZIndexDomEventsHandlersInfoConstructorParams) {\n    this.app = params.app;\n    this.path = params.path;\n    this.el = params.el;\n\n    if (this.el.isConnected) {\n      this.updateZIndex(this.el);\n    } else {\n      this.el.onNodeInserted(() => {\n        this.updateZIndex(this.el);\n      });\n    }\n  }\n\n  private updateZIndex(el: HTMLElement): void {\n    this.zIndex = getZIndex(el) + 1;\n  }\n}\n\n/**\n * Render the markdown and embeds.\n *\n * @param params - The parameters for the full render.\n * @returns The {@link Promise} that resolves when the full render is complete.\n */\nexport async function fullRender(params: FullRenderParams): Promise<void> {\n  const sourcePath = params.sourcePath ?? '/';\n  let shouldUnloadComponent = false;\n  let component: Component;\n  if (params.component) {\n    component = params.component;\n  } else {\n    component = new Component();\n    component.load();\n    shouldUnloadComponent = true;\n  }\n\n  using _ = component.addChild(new EmbedByExtensionMdPatchComponent(params.app.embedRegistry.embedByExtension));\n\n  await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);\n\n  if (shouldUnloadComponent) {\n    component.unload();\n  }\n\n  if (params.shouldRegisterLinkHandlers) {\n    await registerLinkHandlers(params.app, params.el, params.sourcePath);\n  }\n}\n\n/**\n * Converts Markdown to HTML.\n *\n * @param app - The Obsidian app instance.\n * @param markdown - The Markdown string to convert.\n * @param sourcePath - (optional) The source path to resolve relative links.\n * @returns The HTML string.\n */\nexport async function markdownToHtml(app: App, markdown: string, sourcePath?: string): Promise<string> {\n  const component = new Component();\n  component.load();\n  const renderDiv = createDiv();\n  await MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? '', component);\n  const html = renderDiv.innerHTML;\n  component.unload();\n  return html;\n}\n\n/**\n * Registers link handlers for the given element.\n *\n * @param app - The Obsidian app instance.\n * @param el - The HTMLElement to register link handlers for.\n * @param sourcePath - The source path to resolve relative links from.\n */\nexport async function registerLinkHandlers(app: App, el: HTMLElement, sourcePath?: string): Promise<void> {\n  // eslint-disable-next-line require-atomic-updates -- No race condition.\n  domEventsHandlersConstructor ??= await getDomEventsHandlersConstructor(app);\n  MarkdownPreviewRenderer.registerDomEvents(\n    el,\n    new domEventsHandlersConstructor(\n      new FixedZIndexDomEventsHandlersInfo({\n        app,\n        el,\n        path: sourcePath ?? ''\n      })\n    )\n  );\n}\n\n/**\n * Renders an external link.\n *\n * @param app - The Obsidian app instance.\n * @param url - The URL to render the external link for.\n * @param displayText - The text to display for the external link.\n * @returns The HTMLAnchorElement containing the rendered external link.\n */\nexport async function renderExternalLink(app: App, url: string, displayText?: string): Promise<HTMLAnchorElement> {\n  displayText ??= url;\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[${displayText}](${url})`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/* v8 ignore stop */\n\n/**\n * Renders an internal link.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrAbstractFile - The path or abstract file to render the internal link for.\n * @param displayText - The text to display for the internal link.\n * @returns The HTMLAnchorElement containing the rendered internal link.\n */\nexport async function renderInternalLink(app: App, pathOrAbstractFile: PathOrAbstractFile, displayText?: string): Promise<HTMLAnchorElement> {\n  const abstractFile = getAbstractFileOrNull(app, pathOrAbstractFile);\n  const path = getPath(app, pathOrAbstractFile);\n  displayText ??= path;\n  if (isFolder(abstractFile)) {\n    return createEl('a', { text: displayText }, (aEl) => {\n      aEl.addEventListener('click', (evt) => {\n        evt.preventDefault();\n        app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer)?.revealInFolder(abstractFile);\n      });\n    });\n  }\n\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[[${path}|${displayText}]]`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,6BAAmC;AACnC,sBAKO;AAIP,0BAA0B;AAC1B,qCAAsC;AACtC,6CAAgD;AAChD,yBAIO;AAIP,IAAI,+BAAoE;AA2CxE,MAAM,yCAAyC,qDAAsB;AAAA,EAC5D,YAA6B,kBAAuD;AACzF,UAAM;AAD4B;AAAA,EAEpC;AAAA,EAFoC;AAAA,EAIpB,SAAe;AAC7B,SAAK,oBAAoB;AAAA,MACvB,YAAY;AAAA,MACZ,KAAK,KAAK;AAAA,MACV,cAAc,CAAC;AAAA,QACb;AAAA,QACA,cAAc,CAAC,OAAO;AAAA,MACxB,MAAM;AACJ,gBAAQ,cAAc;AACtB,eAAO,SAAS;AAAA,MAClB;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEA,MAAM,iCAAkE;AAAA,EACtD;AAAA,EACA;AAAA,EACA;AAAA,EAEhB,IAAW,eAAoC;AAC7C,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAW,aAAa,cAAmC;AACzD,SAAK,gBAAgB;AACrB,QAAI,gBAAgB,KAAK,WAAW,QAAW;AAC7C,mBAAa,QAAQ,aAAa;AAAA,QAChC,QAAQ,OAAO,KAAK,MAAM;AAAA,MAC5B,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEQ,gBAAqC;AAAA,EAErC;AAAA,EAED,YAAY,QAA2D;AAC5E,SAAK,MAAM,OAAO;AAClB,SAAK,OAAO,OAAO;AACnB,SAAK,KAAK,OAAO;AAEjB,QAAI,KAAK,GAAG,aAAa;AACvB,WAAK,aAAa,KAAK,EAAE;AAAA,IAC3B,OAAO;AACL,WAAK,GAAG,eAAe,MAAM;AAC3B,aAAK,aAAa,KAAK,EAAE;AAAA,MAC3B,CAAC;AAAA,IACH;AAAA,EACF;AAAA,EAEQ,aAAa,IAAuB;AAC1C,SAAK,aAAS,+BAAU,EAAE,IAAI;AAAA,EAChC;AACF;AAQA,eAAsB,WAAW,QAAyC;AAYxE;AAAA;AAXA,UAAM,aAAa,OAAO,cAAc;AACxC,QAAI,wBAAwB;AAC5B,QAAI;AACJ,QAAI,OAAO,WAAW;AACpB,kBAAY,OAAO;AAAA,IACrB,OAAO;AACL,kBAAY,IAAI,0BAAU;AAC1B,gBAAU,KAAK;AACf,8BAAwB;AAAA,IAC1B;AAEA,UAAM,IAAI,0BAAU,SAAS,IAAI,iCAAiC,OAAO,IAAI,cAAc,gBAAgB,CAAC;AAE5G,UAAM,iCAAiB,OAAO,OAAO,KAAK,OAAO,UAAU,OAAO,IAAI,YAAY,SAAS;AAE3F,QAAI,uBAAuB;AACzB,gBAAU,OAAO;AAAA,IACnB;AAEA,QAAI,OAAO,4BAA4B;AACrC,YAAM,qBAAqB,OAAO,KAAK,OAAO,IAAI,OAAO,UAAU;AAAA,IACrE;AAAA,WAVAA,IAAA;AAAA,iBAAAA,IAAA;AAAA;AAAA;AAAA;AAWF;AAUA,eAAsB,eAAe,KAAU,UAAkB,YAAsC;AACrG,QAAM,YAAY,IAAI,0BAAU;AAChC,YAAU,KAAK;AACf,QAAM,YAAY,UAAU;AAC5B,QAAM,iCAAiB,OAAO,KAAK,UAAU,WAAW,cAAc,IAAI,SAAS;AACnF,QAAM,OAAO,UAAU;AACvB,YAAU,OAAO;AACjB,SAAO;AACT;AASA,eAAsB,qBAAqB,KAAU,IAAiB,YAAoC;AAExG,mCAAiC,UAAM,wEAAgC,GAAG;AAC1E,0CAAwB;AAAA,IACtB;AAAA,IACA,IAAI;AAAA,MACF,IAAI,iCAAiC;AAAA,QACnC;AAAA,QACA;AAAA,QACA,MAAM,cAAc;AAAA,MACtB,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAUA,eAAsB,mBAAmB,KAAU,KAAa,aAAkD;AAChH,kBAAgB;AAChB,QAAM,YAAY,WAAW;AAC7B,QAAM,WAAW;AAAA,IACf;AAAA,IACA,IAAI;AAAA,IACJ,UAAU,IAAI,WAAW,KAAK,GAAG;AAAA,EACnC,CAAC;AACD,QAAM,MAAM,UAAU,KAAK,GAAG;AAC9B,QAAM,qBAAqB,KAAK,GAAG;AACnC,SAAO;AACT;AAYA,eAAsB,mBAAmB,KAAU,oBAAwC,aAAkD;AAC3I,QAAM,mBAAe,0CAAsB,KAAK,kBAAkB;AAClE,QAAM,WAAO,4BAAQ,KAAK,kBAAkB;AAC5C,kBAAgB;AAChB,UAAI,6BAAS,YAAY,GAAG;AAC1B,WAAO,SAAS,KAAK,EAAE,MAAM,YAAY,GAAG,CAACC,SAAQ;AACnD,MAAAA,KAAI,iBAAiB,SAAS,CAAC,QAAQ;AACrC,YAAI,eAAe;AACnB,YAAI,gBAAgB,qBAAqB,0CAAmB,YAAY,GAAG,eAAe,YAAY;AAAA,MACxG,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,YAAY,WAAW;AAC7B,QAAM,WAAW;AAAA,IACf;AAAA,IACA,IAAI;AAAA,IACJ,UAAU,KAAK,IAAI,IAAI,WAAW;AAAA,EACpC,CAAC;AACD,QAAM,MAAM,UAAU,KAAK,GAAG;AAC9B,QAAM,qBAAqB,KAAK,GAAG;AACnC,SAAO;AACT;",
  "names": ["_", "aEl"]
}


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

@@ -87,6 +87,16 @@ interface CreateFunctionParams<TFunction extends GenericFunction> extends Create
 type MapToArgNames<TArgs extends readonly unknown[]> = {
     readonly [K in keyof TArgs]: string;
 };
+/**
+ * Clone a function by creating a new function that calls the original function.
+ *
+ * This is useful for creating a new instance of a function that has the same behavior but is not strictly equal to the original function.
+ *
+ * @typeParam TFunction - The type of the function to clone.
+ * @param fn - The function to clone.
+ * @returns A new function that has the same behavior as the original function.
+ */
+export declare function cloneFunction<TFunction extends GenericFunction>(fn: TFunction): TFunction;
 /**
  * Creates a function from the provided parameters.
  *

package/dist/lib/esm/function.mjs

@@ -45,6 +45,12 @@ function omitAsyncReturnType(fn) {
 }
 const FUNCTION_EXPRESSION_RE = /^(?:function\b|async\b\s*(?:function\b|\()|\()/;
 const ASYNC_KEYWORD_RE = /^async\b\s*/;
+function cloneFunction(fn) {
+  return clonedFn;
+  function clonedFn(...args) {
+    return fn.apply(this, args);
+  }
+}
 function createFunction(params) {
   const argNames = params.argNames ?? [];
   return new Function(...argNames, params.functionBody);
@@ -55,6 +61,7 @@ function omitReturnType(fn) {
   };
 }
 export {
+  cloneFunction,
   createFunction,
   getFunctionExpressionString,
   noop,
@@ -63,4 +70,4 @@ export {
   omitAsyncReturnType,
   omitReturnType
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/function.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions and types for working with functions.\n */\n\nimport type { Promisable } from 'type-fest';\n\n/**\n * Represents a generic async function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericAsyncFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promise<Return>>;\n\n/**\n * Represents a generic async void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericAsyncVoidFunction<Args extends unknown[] = never[]> = GenericAsyncFunction<Args, void>;\n\n/**\n * Represents a generic function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The return type of the function.\n */\nexport type GenericFunction<Args extends unknown[] = never[], Return = unknown> = (...args: Args) => Return;\n\n/**\n * Represents a generic promisable function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericPromisableFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promisable<Return>>;\n\n/**\n * Represents a generic promisable void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericPromisableVoidFunction<Args extends unknown[] = never[]> = GenericPromisableFunction<Args, void>;\n\n/**\n * Represents a generic void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericVoidFunction<Args extends unknown[] = never[]> = GenericFunction<Args, void>;\n\n/**\n * Converts a function into a string that is a valid function expression.\n *\n * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`\n * returns `\"fn() {}\"`, which is not a valid expression.\n * This helper detects that form and prefixes it with `function `.\n *\n * @param fn - The function to convert.\n * @returns A string that is a valid function expression.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type.\nexport function getFunctionExpressionString(fn: Function): string {\n  const fnString = fn.toString();\n\n  if (FUNCTION_EXPRESSION_RE.test(fnString)) {\n    return fnString;\n  }\n\n  const asyncMatch = ASYNC_KEYWORD_RE.exec(fnString);\n  if (asyncMatch) {\n    return `async function ${fnString.slice(asyncMatch[0].length)}`;\n  }\n\n  return `function ${fnString}`;\n}\n\n/**\n * A function that does nothing.\n */\nexport function noop(): void {\n  // Does nothing.\n}\n\n/**\n * A singleton no-op promise.\n */\n// eslint-disable-next-line obsidian-dev-utils/prefer-noop-async -- Avoid circular reference.\nexport const noopAsyncSingletonPromise = Promise.resolve();\n\n/**\n * A function that does nothing.\n *\n * @returns A promise that resolves when the function is complete.\n */\nexport function noopAsync(): Promise<void> {\n  return noopAsyncSingletonPromise;\n}\n\n/**\n * Makes an async function that calls the original async function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns An async function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitAsyncReturnType<Args extends unknown[]>(fn: GenericAsyncFunction<Args>): GenericAsyncVoidFunction<Args> {\n  return async (...args: Args) => {\n    await fn(...args);\n  };\n}\n\n/**\n * Matches strings that are already valid function expressions:\n * - `function ...` (keyword, not identifier like `function1`)\n * - `(` (arrow function)\n * - `async\\b` followed by `function\\b` or `(` (async function/arrow)\n */\nconst FUNCTION_EXPRESSION_RE = /^(?:function\\b|async\\b\\s*(?:function\\b|\\()|\\()/;\n\n/**\n * Matches the `async` keyword (word boundary, not `async1`) followed by optional whitespace.\n * Used to strip the `async` prefix from async shorthand methods before re-adding `async function`.\n */\nconst ASYNC_KEYWORD_RE = /^async\\b\\s*/;\n\ntype ArgNamesOf<T extends GenericFunction> = MapToArgNames<Parameters<T>>;\n\ninterface CreateFunctionArgumentlessParams {\n  readonly functionBody: string;\n}\n\ninterface CreateFunctionParams<TFunction extends GenericFunction> extends CreateFunctionArgumentlessParams {\n  readonly argNames: ArgNamesOf<TFunction>;\n}\n\ntype MapToArgNames<TArgs extends readonly unknown[]> = {\n  readonly [K in keyof TArgs]: string;\n};\n\n/**\n * Creates a function from the provided parameters.\n *\n * Function is argumentless, so `argNames` is not needed.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need return type.\nexport function createFunction<TFunction extends () => unknown>(params: CreateFunctionArgumentlessParams): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * Function has arguments, so `argNames` is required.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(params: CreateFunctionParams<TFunction>): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * @typeParam TFunction - The type of the function to create.\n *\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(\n  params: CreateFunctionArgumentlessParams & Partial<CreateFunctionParams<TFunction>>\n): TFunction {\n  const argNames = params.argNames ?? [];\n  // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval -- Need function constructor\n  return new Function(...argNames, params.functionBody) as TFunction;\n}\n\n/**\n * Makes a function that calls the original function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns A function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitReturnType<Args extends unknown[]>(fn: GenericFunction<Args>): GenericVoidFunction<Args> {\n  return (...args: Args) => {\n    fn(...args);\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAgEO,SAAS,4BAA4B,IAAsB;AAChE,QAAM,WAAW,GAAG,SAAS;AAE7B,MAAI,uBAAuB,KAAK,QAAQ,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,iBAAiB,KAAK,QAAQ;AACjD,MAAI,YAAY;AACd,WAAO,kBAAkB,SAAS,MAAM,WAAW,CAAC,EAAE,MAAM,CAAC;AAAA,EAC/D;AAEA,SAAO,YAAY,QAAQ;AAC7B;AAKO,SAAS,OAAa;AAE7B;AAMO,MAAM,4BAA4B,QAAQ,QAAQ;AAOlD,SAAS,YAA2B;AACzC,SAAO;AACT;AASO,SAAS,oBAA4C,IAAgE;AAC1H,SAAO,UAAU,SAAe;AAC9B,UAAM,GAAG,GAAG,IAAI;AAAA,EAClB;AACF;AAQA,MAAM,yBAAyB;AAM/B,MAAM,mBAAmB;AA6ClB,SAAS,eACd,QACW;AACX,QAAM,WAAW,OAAO,YAAY,CAAC;AAErC,SAAO,IAAI,SAAS,GAAG,UAAU,OAAO,YAAY;AACtD;AASO,SAAS,eAAuC,IAAsD;AAC3G,SAAO,IAAI,SAAe;AACxB,OAAG,GAAG,IAAI;AAAA,EACZ;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/function.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions and types for working with functions.\n */\n\nimport type { Promisable } from 'type-fest';\n\n/**\n * Represents a generic async function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericAsyncFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promise<Return>>;\n\n/**\n * Represents a generic async void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericAsyncVoidFunction<Args extends unknown[] = never[]> = GenericAsyncFunction<Args, void>;\n\n/**\n * Represents a generic function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The return type of the function.\n */\nexport type GenericFunction<Args extends unknown[] = never[], Return = unknown> = (...args: Args) => Return;\n\n/**\n * Represents a generic promisable function.\n *\n * @typeParam Args - The arguments of the function.\n * @typeParam Return - The awaited return type of the function.\n */\nexport type GenericPromisableFunction<Args extends unknown[] = never[], Return = unknown> = GenericFunction<Args, Promisable<Return>>;\n\n/**\n * Represents a generic promisable void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericPromisableVoidFunction<Args extends unknown[] = never[]> = GenericPromisableFunction<Args, void>;\n\n/**\n * Represents a generic void function.\n *\n * @typeParam Args - The arguments of the function.\n */\nexport type GenericVoidFunction<Args extends unknown[] = never[]> = GenericFunction<Args, void>;\n\n/**\n * Converts a function into a string that is a valid function expression.\n *\n * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`\n * returns `\"fn() {}\"`, which is not a valid expression.\n * This helper detects that form and prefixes it with `function `.\n *\n * @param fn - The function to convert.\n * @returns A string that is a valid function expression.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type.\nexport function getFunctionExpressionString(fn: Function): string {\n  const fnString = fn.toString();\n\n  if (FUNCTION_EXPRESSION_RE.test(fnString)) {\n    return fnString;\n  }\n\n  const asyncMatch = ASYNC_KEYWORD_RE.exec(fnString);\n  if (asyncMatch) {\n    return `async function ${fnString.slice(asyncMatch[0].length)}`;\n  }\n\n  return `function ${fnString}`;\n}\n\n/**\n * A function that does nothing.\n */\nexport function noop(): void {\n  // Does nothing.\n}\n\n/**\n * A singleton no-op promise.\n */\n// eslint-disable-next-line obsidian-dev-utils/prefer-noop-async -- Avoid circular reference.\nexport const noopAsyncSingletonPromise = Promise.resolve();\n\n/**\n * A function that does nothing.\n *\n * @returns A promise that resolves when the function is complete.\n */\nexport function noopAsync(): Promise<void> {\n  return noopAsyncSingletonPromise;\n}\n\n/**\n * Makes an async function that calls the original async function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns An async function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitAsyncReturnType<Args extends unknown[]>(fn: GenericAsyncFunction<Args>): GenericAsyncVoidFunction<Args> {\n  return async (...args: Args) => {\n    await fn(...args);\n  };\n}\n\n/**\n * Matches strings that are already valid function expressions:\n * - `function ...` (keyword, not identifier like `function1`)\n * - `(` (arrow function)\n * - `async\\b` followed by `function\\b` or `(` (async function/arrow)\n */\nconst FUNCTION_EXPRESSION_RE = /^(?:function\\b|async\\b\\s*(?:function\\b|\\()|\\()/;\n\n/**\n * Matches the `async` keyword (word boundary, not `async1`) followed by optional whitespace.\n * Used to strip the `async` prefix from async shorthand methods before re-adding `async function`.\n */\nconst ASYNC_KEYWORD_RE = /^async\\b\\s*/;\n\ntype ArgNamesOf<T extends GenericFunction> = MapToArgNames<Parameters<T>>;\n\ninterface CreateFunctionArgumentlessParams {\n  readonly functionBody: string;\n}\n\ninterface CreateFunctionParams<TFunction extends GenericFunction> extends CreateFunctionArgumentlessParams {\n  readonly argNames: ArgNamesOf<TFunction>;\n}\n\ntype MapToArgNames<TArgs extends readonly unknown[]> = {\n  readonly [K in keyof TArgs]: string;\n};\n\n/**\n * Clone a function by creating a new function that calls the original function.\n *\n * This is useful for creating a new instance of a function that has the same behavior but is not strictly equal to the original function.\n *\n * @typeParam TFunction - The type of the function to clone.\n * @param fn - The function to clone.\n * @returns A new function that has the same behavior as the original function.\n */\nexport function cloneFunction<TFunction extends GenericFunction>(fn: TFunction): TFunction {\n  return clonedFn as TFunction;\n\n  function clonedFn(this: ThisParameterType<TFunction>, ...args: Parameters<TFunction>): ReturnType<TFunction> {\n    return fn.apply(this, args) as ReturnType<TFunction>;\n  }\n}\n/**\n * Creates a function from the provided parameters.\n *\n * Function is argumentless, so `argNames` is not needed.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- We need return type.\nexport function createFunction<TFunction extends () => unknown>(params: CreateFunctionArgumentlessParams): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * Function has arguments, so `argNames` is required.\n *\n * @typeParam TFunction - The type of the function to create.\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(params: CreateFunctionParams<TFunction>): TFunction;\n/**\n * Creates a function from the provided parameters.\n *\n * @typeParam TFunction - The type of the function to create.\n *\n * @param params - The parameters to create the function with.\n * @returns A function created from the provided parameters.\n */\nexport function createFunction<TFunction extends GenericFunction>(\n  params: CreateFunctionArgumentlessParams & Partial<CreateFunctionParams<TFunction>>\n): TFunction {\n  const argNames = params.argNames ?? [];\n  // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval -- Need function constructor\n  return new Function(...argNames, params.functionBody) as TFunction;\n}\n\n/**\n * Makes a function that calls the original function with the provided arguments and omits the return value.\n *\n * @typeParam Args - Arguments to be passed to the function.\n * @param fn - Function to be called.\n * @returns A function that calls the original function with the provided arguments and omits the return value.\n */\nexport function omitReturnType<Args extends unknown[]>(fn: GenericFunction<Args>): GenericVoidFunction<Args> {\n  return (...args: Args) => {\n    fn(...args);\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAgEO,SAAS,4BAA4B,IAAsB;AAChE,QAAM,WAAW,GAAG,SAAS;AAE7B,MAAI,uBAAuB,KAAK,QAAQ,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,iBAAiB,KAAK,QAAQ;AACjD,MAAI,YAAY;AACd,WAAO,kBAAkB,SAAS,MAAM,WAAW,CAAC,EAAE,MAAM,CAAC;AAAA,EAC/D;AAEA,SAAO,YAAY,QAAQ;AAC7B;AAKO,SAAS,OAAa;AAE7B;AAMO,MAAM,4BAA4B,QAAQ,QAAQ;AAOlD,SAAS,YAA2B;AACzC,SAAO;AACT;AASO,SAAS,oBAA4C,IAAgE;AAC1H,SAAO,UAAU,SAAe;AAC9B,UAAM,GAAG,GAAG,IAAI;AAAA,EAClB;AACF;AAQA,MAAM,yBAAyB;AAM/B,MAAM,mBAAmB;AAyBlB,SAAS,cAAiD,IAA0B;AACzF,SAAO;AAEP,WAAS,YAAgD,MAAoD;AAC3G,WAAO,GAAG,MAAM,MAAM,IAAI;AAAA,EAC5B;AACF;AA8BO,SAAS,eACd,QACW;AACX,QAAM,WAAW,OAAO,YAAY,CAAC;AAErC,SAAO,IAAI,SAAS,GAAG,UAAU,OAAO,YAAY;AACtD;AASO,SAAS,eAAuC,IAAsD;AAC3G,SAAO,IAAI,SAAe;AACxB,OAAG,GAAG,IAAI;AAAA,EACZ;AACF;",
  "names": []
}


package/dist/lib/esm/library.mjs

@@ -21,7 +21,7 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-const LIBRARY_VERSION = "74.0.0";
+const LIBRARY_VERSION = "74.1.0";
 const LIBRARY_NAME = "obsidian-dev-utils";
 const LIBRARY_STYLES = ".obsidian-dev-utils.code-highlighter-component textarea, .obsidian-dev-utils.code-highlighter-component pre, .obsidian-dev-utils.code-highlighter-component code {\n  font-family: var(--font-monospace);\n  line-height: var(--line-height-normal);\n  margin: 0;\n}\n.obsidian-dev-utils.code-highlighter-component textarea, .obsidian-dev-utils.code-highlighter-component code {\n  font-size: var(--code-size);\n}\n.obsidian-dev-utils.code-highlighter-component textarea {\n  background: transparent;\n  color: transparent;\n  z-index: 2;\n  width: 20em;\n  height: 10em;\n}\n.obsidian-dev-utils.code-highlighter-component pre {\n  position: absolute;\n  pointer-events: none;\n  border: var(--input-border-width) solid transparent;\n  overflow: auto;\n  inset: 0;\n  padding: var(--size-4-1) var(--size-4-2);\n  z-index: 1;\n}\n.obsidian-dev-utils.code-highlighter-component pre::after {\n  content: \"\";\n  display: block;\n  height: var(--bottom-gap, 0);\n}\n.obsidian-dev-utils.code-highlighter-component pre.is-placeholder {\n  opacity: 0.6;\n}\n.obsidian-dev-utils.code-highlighter-component code {\n  display: block;\n  padding: 0;\n}\n\n.obsidian-dev-utils input[type=url] {\n  height: var(--input-height);\n}\n.obsidian-dev-utils input[type=month],\n.obsidian-dev-utils input[type=tel],\n.obsidian-dev-utils input[type=time],\n.obsidian-dev-utils input[type=url],\n.obsidian-dev-utils input[type=week] {\n  -webkit-app-region: no-drag;\n  background: var(--background-modifier-form-field);\n  border: var(--input-border-width) solid var(--background-modifier-border);\n  color: var(--text-normal);\n  font-family: inherit;\n  padding: var(--size-4-1) var(--size-4-2);\n  font-size: var(--font-ui-small);\n  border-radius: var(--input-radius);\n  outline: none;\n}\n@media (hover: hover) {\n  .obsidian-dev-utils input[type=month]:hover,\n  .obsidian-dev-utils input[type=tel]:hover,\n  .obsidian-dev-utils input[type=time]:hover,\n  .obsidian-dev-utils input[type=url]:hover,\n  .obsidian-dev-utils input[type=week]:hover {\n    border-color: var(--background-modifier-border-hover);\n    transition: box-shadow 0.15s ease-in-out, border 0.15s ease-in-out;\n  }\n}\n.obsidian-dev-utils input[type=month]:active, .obsidian-dev-utils input[type=month]:focus,\n.obsidian-dev-utils input[type=tel]:active,\n.obsidian-dev-utils input[type=tel]:focus,\n.obsidian-dev-utils input[type=time]:active,\n.obsidian-dev-utils input[type=time]:focus,\n.obsidian-dev-utils input[type=url]:active,\n.obsidian-dev-utils input[type=url]:focus,\n.obsidian-dev-utils input[type=week]:active,\n.obsidian-dev-utils input[type=week]:focus {\n  border-color: var(--background-modifier-border-focus);\n  transition: box-shadow 0.15s ease-in-out, border 0.15s ease-in-out;\n}\n.obsidian-dev-utils input[type=month]:active, .obsidian-dev-utils input[type=month]:focus, .obsidian-dev-utils input[type=month]:focus-visible,\n.obsidian-dev-utils input[type=tel]:active,\n.obsidian-dev-utils input[type=tel]:focus,\n.obsidian-dev-utils input[type=tel]:focus-visible,\n.obsidian-dev-utils input[type=time]:active,\n.obsidian-dev-utils input[type=time]:focus,\n.obsidian-dev-utils input[type=time]:focus-visible,\n.obsidian-dev-utils input[type=url]:active,\n.obsidian-dev-utils input[type=url]:focus,\n.obsidian-dev-utils input[type=url]:focus-visible,\n.obsidian-dev-utils input[type=week]:active,\n.obsidian-dev-utils input[type=week]:focus,\n.obsidian-dev-utils input[type=week]:focus-visible {\n  box-shadow: 0 0 0 2px var(--background-modifier-border-focus);\n}\n.obsidian-dev-utils input[type=month]::placeholder,\n.obsidian-dev-utils input[type=tel]::placeholder,\n.obsidian-dev-utils input[type=time]::placeholder,\n.obsidian-dev-utils input[type=url]::placeholder,\n.obsidian-dev-utils input[type=week]::placeholder {\n  color: var(--text-faint);\n}\n.mod-rtl input[type=month],\n.mod-rtl input[type=time],\n.mod-rtl input[type=week],\n.is-rtl input[type=month],\n.is-rtl input[type=time],\n.is-rtl input[type=week],\n.rtl input[type=month],\n.rtl input[type=time],\n.rtl input[type=week] {\n  direction: rtl;\n}\n.mod-rtl input[type=month]::-webkit-calendar-picker-indicator,\n.mod-rtl input[type=time]::-webkit-calendar-picker-indicator,\n.mod-rtl input[type=week]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=month]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=time]::-webkit-calendar-picker-indicator,\n.is-rtl input[type=week]::-webkit-calendar-picker-indicator,\n.rtl input[type=month]::-webkit-calendar-picker-indicator,\n.rtl input[type=time]::-webkit-calendar-picker-indicator,\n.rtl input[type=week]::-webkit-calendar-picker-indicator {\n  right: var(--size-4-1);\n  left: auto;\n}\n\n.obsidian-dev-utils input[type=month],\n.obsidian-dev-utils input[type=time],\n.obsidian-dev-utils input[type=week] {\n  font-variant-numeric: tabular-nums;\n  position: relative;\n}\n.obsidian-dev-utils input[type=month]::-webkit-datetime-edit-text,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-text,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-text {\n  color: var(--text-faint);\n  padding-inline-end: 0;\n}\n.obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator,\n.obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator {\n  position: absolute;\n  left: var(--size-4-1);\n  right: auto;\n  opacity: 0.5;\n}\n.obsidian-dev-utils input[type=month]::-webkit-datetime-edit-month-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-month-field:focus, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-day-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-day-field:focus, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-year-field:active, .obsidian-dev-utils input[type=month]::-webkit-datetime-edit-year-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-month-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-month-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-day-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-day-field:focus,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-year-field:active,\n.obsidian-dev-utils input[type=time]::-webkit-datetime-edit-year-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-month-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-month-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-day-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-day-field:focus,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-year-field:active,\n.obsidian-dev-utils input[type=week]::-webkit-datetime-edit-year-field:focus {\n  background-color: var(--text-selection);\n  color: var(--text-normal);\n  cursor: text;\n}\n.mod-rtl .obsidian-dev-utils input[type=month], .is-rtl .obsidian-dev-utils input[type=month], .rtl .obsidian-dev-utils input[type=month],\n.mod-rtl .obsidian-dev-utils input[type=time],\n.is-rtl .obsidian-dev-utils input[type=time],\n.rtl .obsidian-dev-utils input[type=time],\n.mod-rtl .obsidian-dev-utils input[type=week],\n.is-rtl .obsidian-dev-utils input[type=week],\n.rtl .obsidian-dev-utils input[type=week] {\n  direction: rtl;\n}\n.mod-rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator, .is-rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator, .rtl .obsidian-dev-utils input[type=month]::-webkit-calendar-picker-indicator,\n.mod-rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.is-rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.rtl .obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator,\n.mod-rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator,\n.is-rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator,\n.rtl .obsidian-dev-utils input[type=week]::-webkit-calendar-picker-indicator {\n  left: auto;\n  right: var(--size-4-1);\n}\n\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=month],\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=time],\nbody:not(.is-ios):not(.is-android) .obsidian-dev-utils input[type=week] {\n  padding-inline-start: var(--size-4-6);\n}\n\n.obsidian-dev-utils input[type=time]::-webkit-calendar-picker-indicator {\n  margin-inline-start: 0;\n}\n\n.obsidian-dev-utilsprogress.loop {\n  min-width: 200px;\n}\n\n.obsidian-dev-utils.modal-container .ok-button {\n  margin-right: 10px;\n  margin-top: 20px;\n}\n\n.obsidian-dev-utils .multiple-dropdown-component select,\n.obsidian-dev-utils .multiple-dropdown-component select:focus,\n.obsidian-dev-utils .multiple-dropdown-component .dropdown {\n  height: auto;\n  padding-top: 3px;\n}\n.obsidian-dev-utils .multiple-dropdown-component select option:checked,\n.obsidian-dev-utils .multiple-dropdown-component select:focus option:checked,\n.obsidian-dev-utils .multiple-dropdown-component .dropdown option:checked {\n  background-color: #1967d2;\n  color: #fff;\n}\n\n.obsidian-dev-utils.plugin-settings-tab a:focus {\n  outline: 2px solid var(--link-color);\n}\n\n.obsidian-dev-utils.prompt-modal .text-box {\n  width: 100%;\n}\n\n.obsidian-dev-utils.tri-state-checkbox-component input[type=checkbox]:indeterminate {\n  appearance: checkbox;\n}\n\n.obsidian-dev-utils :invalid {\n  box-shadow: 0 0 0 2px var(--text-error);\n}\n.obsidian-dev-utils input.metadata-input-text:active:invalid, .obsidian-dev-utils input.metadata-input-text:focus-visible:invalid, .obsidian-dev-utils input.metadata-input-text:focus:invalid,\n.obsidian-dev-utils input[type=date]:active:invalid,\n.obsidian-dev-utils input[type=date]:focus-visible:invalid,\n.obsidian-dev-utils input[type=date]:focus:invalid,\n.obsidian-dev-utils input[type=datetime-local]:active:invalid,\n.obsidian-dev-utils input[type=datetime-local]:focus-visible:invalid,\n.obsidian-dev-utils input[type=datetime-local]:focus:invalid,\n.obsidian-dev-utils input[type=email]:active:invalid,\n.obsidian-dev-utils input[type=email]:focus-visible:invalid,\n.obsidian-dev-utils input[type=email]:focus:invalid,\n.obsidian-dev-utils input[type=number]:active:invalid,\n.obsidian-dev-utils input[type=number]:focus-visible:invalid,\n.obsidian-dev-utils input[type=number]:focus:invalid,\n.obsidian-dev-utils input[type=password]:active:invalid,\n.obsidian-dev-utils input[type=password]:focus-visible:invalid,\n.obsidian-dev-utils input[type=password]:focus:invalid,\n.obsidian-dev-utils input[type=search]:active:invalid,\n.obsidian-dev-utils input[type=search]:focus-visible:invalid,\n.obsidian-dev-utils input[type=search]:focus:invalid,\n.obsidian-dev-utils input[type=text]:active:invalid,\n.obsidian-dev-utils input[type=text]:focus-visible:invalid,\n.obsidian-dev-utils input[type=text]:focus:invalid,\n.obsidian-dev-utils textarea:active:invalid,\n.obsidian-dev-utils textarea:focus-visible:invalid,\n.obsidian-dev-utils textarea:focus:invalid {\n  box-shadow: 0 0 0 2px var(--text-error);\n}\n.obsidian-dev-utils.setting-component-wrapper {\n  position: relative;\n  display: inline-flex;\n}\n.obsidian-dev-utils.overlay-validator {\n  caret-color: transparent;\n  cursor: default;\n  position: absolute;\n  background-color: transparent;\n  border: none;\n  outline: none;\n  pointer-events: none;\n  z-index: 9999;\n  left: 0;\n  top: 0;\n  width: 100%;\n  height: 100%;\n}\n.obsidian-dev-utils.tooltip.tooltip-validator {\n  position: absolute;\n  top: calc(100% + 8px);\n  width: max-content;\n}\n\n/*# sourceMappingURL=data:application/json;charset=utf-8,%7B%22version%22:3,%22sourceRoot%22:%22%22,%22sources%22:%5B%22../src/styles/code-highlighter-component.scss%22,%22../src/styles/input.scss%22,%22../src/styles/input-time.scss%22,%22../src/styles/loop.scss%22,%22../src/styles/modal-container.scss%22,%22../src/styles/multiple-dropdown-component.scss%22,%22../src/styles/plugin-settings-tab.scss%22,%22../src/styles/prompt-modal.scss%22,%22../src/styles/tri-state-checkbox-component.scss%22,%22../src/styles/validation.scss%22%5D,%22names%22:%5B%5D,%22mappings%22:%22AAEI;EACE;EACA;EACA;;AAGF;EACE;;AAGF;EACE;EACA;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA;;AAGF;EACE;;AAGF;EACE;EACA;;;ACzCJ;EACE;;AAGF;AAAA;AAAA;AAAA;AAAA;EAKE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGE;EACE;AAAA;AAAA;AAAA;AAAA;IACE;IACA,YACE;;;AAMR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAEE;EACA,YACE;;AAIJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGE;;AAGF;AAAA;AAAA;AAAA;AAAA;EACE;;AASE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGE;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;;AC7DV;AAAA;AAAA;EAGE;EACA;;AAEA;AAAA;AAAA;EACE;EACA;;AAGF;AAAA;AAAA;EACE;EACA;EACA;EACA;;AAMA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAEE;EACA;EACA;;AAIK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EAGP;;AAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EACE;EACA;;;AAKF;AAAA;AAAA;EACE;;;AAMJ;EACE;;;ACjDJ;EACE;;;ACAA;EACE;EACA;;;ACFF;AAAA;AAAA;EAGE;EACA;;AAEA;AAAA;AAAA;EACE;EACA;;;ACRJ;EACE;;;ACDF;EACE;;;ACDF;EACE;;;ACEJ;EAJA;;AAoBI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;EApBJ;;AA0BA;EACE;EACA;;AAGF;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGF;EACE;EACA;EACA%22,%22file%22:%22styles.css%22,%22sourcesContent%22:%5B%22.obsidian-dev-utils%20%7B%5Cn%20%20&.code-highlighter-component%20%7B%5Cn%20%20%20%20textarea,%20pre,%20code%20%7B%5Cn%20%20%20%20%20%20font-family:%20var(--font-monospace);%5Cn%20%20%20%20%20%20line-height:%20var(--line-height-normal);%5Cn%20%20%20%20%20%20margin:%200;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20textarea,%20code%20%7B%5Cn%20%20%20%20%20%20font-size:%20var(--code-size);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20textarea%20%7B%5Cn%20%20%20%20%20%20background:%20transparent;%5Cn%20%20%20%20%20%20color:%20transparent;%5Cn%20%20%20%20%20%20z-index:%202;%5Cn%20%20%20%20%20%20width:%2020em;%5Cn%20%20%20%20%20%20height:%2010em;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20pre%20%7B%5Cn%20%20%20%20%20%20position:%20absolute;%5Cn%20%20%20%20%20%20pointer-events:%20none;%5Cn%20%20%20%20%20%20border:%20var(--input-border-width)%20solid%20transparent;%5Cn%20%20%20%20%20%20overflow:%20auto;%5Cn%20%20%20%20%20%20inset:%200;%5Cn%20%20%20%20%20%20padding:%20var(--size-4-1)%20var(--size-4-2);%5Cn%20%20%20%20%20%20z-index:%201;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20pre::after%20%7B%5Cn%20%20%20%20%20%20content:%20%5C%22%5C%22;%5Cn%20%20%20%20%20%20display:%20block;%5Cn%20%20%20%20%20%20height:%20var(--bottom-gap,%200);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20pre.is-placeholder%20%7B%5Cn%20%20%20%20%20%20opacity:%200.6;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20code%20%7B%5Cn%20%20%20%20%20%20display:%20block;%5Cn%20%20%20%20%20%20padding:%200;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20input%5Btype='url'%5D%20%7B%5Cn%20%20%20%20height:%20var(--input-height)%5Cn%20%20%7D%5Cn%5Cn%20%20input%5Btype='month'%5D,%5Cn%20%20input%5Btype='tel'%5D,%5Cn%20%20input%5Btype='time'%5D,%5Cn%20%20input%5Btype='url'%5D,%5Cn%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20-webkit-app-region:%20no-drag;%5Cn%20%20%20%20background:%20var(--background-modifier-form-field);%5Cn%20%20%20%20border:%20var(--input-border-width)%20solid%20var(--background-modifier-border);%5Cn%20%20%20%20color:%20var(--text-normal);%5Cn%20%20%20%20font-family:%20inherit;%5Cn%20%20%20%20padding:%20var(--size-4-1)%20var(--size-4-2);%5Cn%20%20%20%20font-size:%20var(--font-ui-small);%5Cn%20%20%20%20border-radius:%20var(--input-radius);%5Cn%20%20%20%20outline:%20none;%5Cn%5Cn%20%20%20%20@at-root%20%7B%5Cn%20%20%20%20%20%20@media%20(hover:%20hover)%20%7B%5Cn%20%20%20%20%20%20%20%20&:hover%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20border-color:%20var(--background-modifier-border-hover);%5Cn%20%20%20%20%20%20%20%20%20%20transition:%5Cn%20%20%20%20%20%20%20%20%20%20%20%20box-shadow%200.15s%20ease-in-out,%5Cn%20%20%20%20%20%20%20%20%20%20%20%20border%200.15s%20ease-in-out;%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20border-color:%20var(--background-modifier-border-focus);%5Cn%20%20%20%20%20%20transition:%5Cn%20%20%20%20%20%20%20%20box-shadow%200.15s%20ease-in-out,%5Cn%20%20%20%20%20%20%20%20border%200.15s%20ease-in-out;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus,%5Cn%20%20%20%20&:focus-visible%20%7B%5Cn%20%20%20%20%20%20box-shadow:%200%200%200%202px%20var(--background-modifier-border-focus);%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::placeholder%20%7B%5Cn%20%20%20%20%20%20color:%20var(--text-faint);%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20@at-root%20%7B%5Cn%20%20%20%20.mod-rtl,%5Cn%20%20%20%20.is-rtl,%5Cn%20%20%20%20.rtl%20%7B%5Cn%20%20%20%20%20%20&%20%7B%5Cn%20%20%20%20%20%20%20%20input%5Btype='month'%5D,%5Cn%20%20%20%20%20%20%20%20input%5Btype='time'%5D,%5Cn%20%20%20%20%20%20%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20direction:%20rtl;%5Cn%5Cn%20%20%20%20%20%20%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20%20%20%20%20%20%20right:%20var(--size-4-1);%5Cn%20%20%20%20%20%20%20%20%20%20%20%20left:%20auto;%5Cn%20%20%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%20%20%7D%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20input%5Btype='month'%5D,%5Cn%20%20input%5Btype='time'%5D,%5Cn%20%20input%5Btype='week'%5D%20%7B%5Cn%20%20%20%20font-variant-numeric:%20tabular-nums;%5Cn%20%20%20%20position:%20relative;%5Cn%5Cn%20%20%20%20&::-webkit-datetime-edit-text%20%7B%5Cn%20%20%20%20%20%20color:%20var(--text-faint);%5Cn%20%20%20%20%20%20padding-inline-end:%200;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20position:%20absolute;%5Cn%20%20%20%20%20%20left:%20var(--size-4-1);%5Cn%20%20%20%20%20%20right:%20auto;%5Cn%20%20%20%20%20%20opacity:%200.5;%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20&::-webkit-datetime-edit-month-field,%5Cn%20%20%20%20&::-webkit-datetime-edit-day-field,%5Cn%20%20%20%20&::-webkit-datetime-edit-year-field%20%7B%5Cn%20%20%20%20%20%20&:active,%5Cn%20%20%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20%20%20background-color:%20var(--text-selection);%5Cn%20%20%20%20%20%20%20%20color:%20var(--text-normal);%5Cn%20%20%20%20%20%20%20%20cursor:%20text;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20@at-root%20.mod-rtl%20&,%5Cn%20%20%20%20%20%20.is-rtl%20&,%5Cn%20%20%20%20%20%20.rtl%20&%20%7B%5Cn%20%20%20%20%20%20direction:%20rtl;%5Cn%5Cn%20%20%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20%20%20left:%20auto;%5Cn%20%20%20%20%20%20%20%20right:%20var(--size-4-1);%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%5Cn%20%20%20%20@at-root%20%7B%5Cn%20%20%20%20%20%20body:not(.is-ios):not(.is-android)%20&%20%7B%5Cn%20%20%20%20%20%20%20%20padding-inline-start:%20var(--size-4-6);%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20input%5Btype='time'%5D%20%7B%5Cn%20%20%20%20&::-webkit-calendar-picker-indicator%20%7B%5Cn%20%20%20%20%20%20margin-inline-start:%200;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&progress.loop%20%7B%5Cn%20%20%20%20min-width:%20200px;%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.modal-container%20%7B%5Cn%20%20%20%20.ok-button%20%7B%5Cn%20%20%20%20%20%20margin-right:%2010px;%5Cn%20%20%20%20%20%20margin-top:%2020px;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20.multiple-dropdown-component%20%7B%5Cn%20%20%20%20select,%5Cn%20%20%20%20select:focus,%5Cn%20%20%20%20.dropdown%20%7B%5Cn%20%20%20%20%20%20height:%20auto;%5Cn%20%20%20%20%20%20padding-top:%203px;%5Cn%5Cn%20%20%20%20%20%20option:checked%20%7B%5Cn%20%20%20%20%20%20%20%20background-color:%20%231967d2;%5Cn%20%20%20%20%20%20%20%20color:%20%23fff;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.plugin-settings-tab%20%7B%5Cn%20%20%20%20a:focus%20%7B%5Cn%20%20%20%20%20%20outline:%202px%20solid%20var(--link-color);%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cn%20%20&.prompt-modal%20%7B%5Cn%20%20%20%20.text-box%20%7B%5Cn%20%20%20%20%20%20width:%20100%25;%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%7D%5Cn%22,%22.obsidian-dev-utils%20%7B%5Cr%5Cn%20%20&.tri-state-checkbox-component%20%7B%5Cr%5Cn%20%20%20%20input%5Btype='checkbox'%5D:indeterminate%20%7B%5Cr%5Cn%20%20%20%20%20%20appearance:%20checkbox;%5Cr%5Cn%20%20%20%20%7D%5Cr%5Cn%20%20%7D%5Cr%5Cn%7D%5Cr%5Cn%22,%22@mixin%20invalid%20%7B%5Cn%20%20box-shadow:%200%200%200%202px%20var(--text-error);%5Cn%7D%5Cn%5Cn.obsidian-dev-utils%20%7B%5Cn%20%20:invalid%20%7B%5Cn%20%20%20%20@include%20invalid;%5Cn%20%20%7D%5Cn%5Cn%20%20input.metadata-input-text,%5Cn%20%20input%5Btype='date'%5D,%5Cn%20%20input%5Btype='datetime-local'%5D,%5Cn%20%20input%5Btype='email'%5D,%5Cn%20%20input%5Btype='number'%5D,%5Cn%20%20input%5Btype='password'%5D,%5Cn%20%20input%5Btype='search'%5D,%5Cn%20%20input%5Btype='text'%5D,%5Cn%20%20textarea%20%7B%5Cn%20%20%20%20&:active,%5Cn%20%20%20%20&:focus-visible,%5Cn%20%20%20%20&:focus%20%7B%5Cn%20%20%20%20%20%20&:invalid%20%7B%5Cn%20%20%20%20%20%20%20%20@include%20invalid;%5Cn%20%20%20%20%20%20%7D%5Cn%20%20%20%20%7D%5Cn%20%20%7D%5Cn%5Cn%20%20&.setting-component-wrapper%20%7B%5Cn%20%20%20%20position:%20relative;%5Cn%20%20%20%20display:%20inline-flex;%5Cn%20%20%7D%5Cn%5Cn%20%20&.overlay-validator%20%7B%5Cn%20%20%20%20caret-color:%20transparent;%5Cn%20%20%20%20cursor:%20default;%5Cn%20%20%20%20position:%20absolute;%5Cn%20%20%20%20background-color:%20transparent;%5Cn%20%20%20%20border:%20none;%5Cn%20%20%20%20outline:%20none;%5Cn%20%20%20%20pointer-events:%20none;%5Cn%20%20%20%20z-index:%209999;%5Cn%20%20%20%20left:%200;%5Cn%20%20%20%20top:%200;%5Cn%20%20%20%20width:%20100%25;%5Cn%20%20%20%20height:%20100%25;%5Cn%20%20%7D%5Cn%5Cn%20%20&.tooltip.tooltip-validator%20%7B%5Cn%20%20%20%20position:%20absolute;%5Cn%20%20%20%20top:%20calc(100%25%20+%208px);%5Cn%20%20%20%20width:%20max-content;%5Cn%20%20%7D%5Cn%7D%5Cn%22%5D%7D */\n";
 export {

package/dist/lib/esm/obsidian/components/monkey-around-component.d.mts

@@ -6,6 +6,7 @@
  */
 import type { ConditionalKeys } from 'type-fest';
 import type { GenericFunction } from '../../function.mjs';
+import type { MaybeReturn } from '../../type.mjs';
 import { ComponentEx } from './component-ex.mjs';
 /**
  * A type of the factories to apply to the object.
@@ -38,36 +39,67 @@ export interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends obje
      * An optional token to identify the patch.
      */
     readonly patchToken?: symbol;
+    /**
+     * An optional post-patch handler function that runs after the patch is applied.
+     */
+    readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;
 }
 /**
  * A patch handler function that intercepts calls to a method on an object.
  *
  * @typeParam Obj - The object being patched.
- * @typeParam K - The method name being patched.
+ * @typeParam MethodName - The method name being patched.
  */
-export type PatchHandlerFn<Obj extends object, K extends MethodKeys<Obj>> = (params: PatchHandlerParams<Obj, K>) => ReturnType<Extract<Obj[K], GenericFunction>>;
+export type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (params: PatchHandlerParams<Obj, MethodName>) => ReturnType<ExtractFunction<Obj, MethodName>>;
 /**
  * Parameters passed to a {@link PatchHandlerFn} callback.
  *
  * @typeParam Obj - The object being patched.
- * @typeParam K - The method name being patched.
+ * @typeParam MethodName - The method name being patched.
  */
-export interface PatchHandlerParams<Obj extends object, K extends MethodKeys<Obj>> {
-    fallback(this: void): ReturnType<Extract<Obj[K], GenericFunction>>;
+export interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {
+    fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;
     /**
      * The original arguments of the intercepted call, as a tuple.
      */
-    readonly originalArgs: Parameters<Extract<Obj[K], GenericFunction>>;
+    readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;
     /**
-     * The original (unpatched) function. Call via `originalFn.call(originalThis, ...originalArgs)`.
+     * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.
      */
-    readonly originalMethod: Extract<Obj[K], GenericFunction>;
-    readonly originalMethodBound: OmitThisParameter<Extract<Obj[K], GenericFunction>>;
+    readonly originalMethod: ExtractFunction<Obj, MethodName>;
+    /**
+     * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.
+     */
+    readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;
     /**
      * The original `this` context of the intercepted call.
      */
     readonly originalThis: Obj;
 }
+/**
+ * A post-patch handler function that runs after a patch is applied.
+ *
+ * @typeParam Obj - The object being patched.
+ * @typeParam MethodName - The method name being patched.
+ */
+export type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (params: PostPatchHandlerParams<Obj, MethodName>) => MaybeReturn<ExtractFunction<Obj, MethodName>>;
+/**
+ * Parameters passed to a {@link PostPatchHandlerFn} callback.
+ *
+ * @typeParam Obj - The object being patched.
+ * @typeParam MethodName - The method name being patched.
+ */
+export interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {
+    /**
+     * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.
+     */
+    readonly originalMethod: ExtractFunction<Obj, MethodName>;
+    /**
+     * The patched method.
+     */
+    readonly patchedMethod: ExtractFunction<Obj, MethodName>;
+}
+type ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;
 type MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;
 type Uninstaller = () => void;
 type WrapperFactory<T extends Function | undefined> = (next: T) => T;

package/dist/lib/esm/obsidian/components/monkey-around-component.mjs

@@ -40,7 +40,10 @@ class MonkeyAroundComponent extends ComponentEx {
     }
     this.registerPatch(params.obj, {
       [params.methodName]: (originalMethod) => {
-        return patchedMethod;
+        return params.postPatchHandler?.({
+          originalMethod,
+          patchedMethod
+        }) ?? patchedMethod;
         function patchedMethod(...originalArgs) {
           const originalThis = this;
           return params.patchHandler({
@@ -83,4 +86,4 @@ export {
   around,
   hasPatchToken
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\n\nimport { getObsidianDevUtilsState } from '../app.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<\n  {\n    [Key in ConditionalKeys<Obj, GenericFunction | undefined>]: WrapperFactory<Extract<Obj[Key], GenericFunction | undefined>>;\n  }\n>;\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam K - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, K extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, K>\n) => ReturnType<Extract<Obj[K], GenericFunction>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam K - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, K extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original (unpatched) function. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: Extract<Obj[K], GenericFunction>;\n\n  readonly originalMethodBound: OmitThisParameter<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype WrapperFactory<T extends Function | undefined> = (next: T) => T;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type RawFn = Extract<Obj[MethodName], GenericFunction>;\n    type Fn = GenericFunction<Parameters<RawFn>, ReturnType<RawFn>>;\n    this.registerPatch(params.obj, {\n      [params.methodName]: (originalMethod: Fn): Fn => {\n        return patchedMethod;\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<RawFn>): ReturnType<RawFn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod: originalMethod as RawFn,\n            originalMethodBound: originalMethod.bind(originalThis) as OmitThisParameter<RawFn>,\n            originalThis\n          });\n        }\n      }\n    } as Factories<Obj>);\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState(null, 'monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,UAAU,sBAAsB;AAKzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AA4FrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,cAAc,OAAO,KAAK;AAAA,MAC7B,CAAC,OAAO,UAAU,GAAG,CAAC,mBAA2B;AAC/C,eAAO;AACP,iBAAS,iBAA4B,cAAoD;AAEvF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAmB;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,SAAO,eAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,SAAO,yBAAyB,MAAM,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACvG;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type { MaybeReturn } from '../../type.ts';\n\nimport { getObsidianDevUtilsState } from '../app.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<\n  {\n    [Key in ConditionalKeys<Obj, GenericFunction | undefined>]: WrapperFactory<Extract<Obj[Key], GenericFunction | undefined>>;\n  }\n>;\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, MethodName>\n) => ReturnType<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.\n   */\n  readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PostPatchHandlerParams<Obj, MethodName>\n) => MaybeReturn<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The patched method.\n   */\n  readonly patchedMethod: ExtractFunction<Obj, MethodName>;\n}\n\ntype ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype WrapperFactory<T extends Function | undefined> = (next: T) => T;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type Fn = ExtractFunction<Obj, MethodName>;\n\n    this.registerPatch(params.obj, {\n      [params.methodName]: (originalMethod: Fn): Fn => {\n        return params.postPatchHandler?.({\n          originalMethod,\n          patchedMethod\n        }) ?? patchedMethod;\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<Fn>): ReturnType<Fn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    } as Factories<Obj>);\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState(null, 'monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,UAAU,sBAAsB;AAMzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AAkIrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,cAAc,OAAO,KAAK;AAAA,MAC7B,CAAC,OAAO,UAAU,GAAG,CAAC,mBAA2B;AAC/C,eAAO,OAAO,mBAAmB;AAAA,UAC/B;AAAA,UACA;AAAA,QACF,CAAC,KAAK;AACN,iBAAS,iBAA4B,cAA8C;AAEjF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAmB;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,SAAO,eAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,SAAO,yBAAyB,MAAM,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACvG;",
  "names": []
}


package/dist/lib/esm/obsidian/components/rename-delete-handler-component.d.mts

@@ -100,6 +100,5 @@ export declare class RenameDeleteHandlerComponent extends ComponentEx {
     private handleRename;
     private logRegisteredHandlers;
     private shouldInvokeHandler;
-    private wrapLinkUpdatesHandler;
 }
 export {};