@mnaoumov/obsidian-lib 10.5.0 → 10.6.0

package/dist/lib/esm/bulk-operation-progress.mjs

@@ -5,6 +5,17 @@ if you want to view the source, please visit the github repository of this plugi
 
 import { getObsidianLibState } from "./obsidian-lib-state.mjs";
 const BULK_OPERATION_PROGRESS_STATE_KEY = "bulkOperationProgressV1";
+const BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS = 1e4;
+async function holdBulkOperationWhile(promise) {
+  reportBulkOperationProgress();
+  const intervalId = window.setInterval(reportBulkOperationProgress, BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS);
+  try {
+    return await promise;
+  } finally {
+    window.clearInterval(intervalId);
+    reportBulkOperationProgress();
+  }
+}
 function registerBulkOperationProgressListener(listener) {
   const listeners = getListeners();
   listeners.add(listener);
@@ -25,7 +36,9 @@ function getListeners() {
   return getObsidianLibState(BULK_OPERATION_PROGRESS_STATE_KEY, /* @__PURE__ */ new Set()).value;
 }
 export {
+  BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS,
+  holdBulkOperationWhile,
   registerBulkOperationProgressListener,
   reportBulkOperationProgress
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/case-insensitive-file-index.mjs

@@ -31,6 +31,7 @@ ensureBrowserProcess();
 })();
 
 import { snapshot } from "@mnaoumov/typescript-lib/array";
+import { TFolder } from "obsidian";
 import { getObsidianLibState } from "./obsidian-lib-state.mjs";
 const STATE_KEY = "caseInsensitiveFileIndex";
 class CaseInsensitiveFileIndex {
@@ -60,7 +61,11 @@ class CaseInsensitiveFileIndex {
    */
   delete(path) {
     const key = path.toLowerCase();
+    const abstractFile = this.map.get(key);
     this.map.delete(key);
+    if (abstractFile && !(abstractFile instanceof TFolder)) {
+      return;
+    }
     const descendantPrefix = `${key}/`;
     for (const existingKey of snapshot(this.map.keys())) {
       if (existingKey.startsWith(descendantPrefix)) {
@@ -102,6 +107,9 @@ class CaseInsensitiveFileIndex {
     const newKey = newAbstractFile.path.toLowerCase();
     this.map.delete(oldKey);
     this.map.set(newKey, newAbstractFile);
+    if (!(newAbstractFile instanceof TFolder)) {
+      return;
+    }
     const oldDescendantPrefix = `${oldKey}/`;
     const newDescendantPrefix = `${newKey}/`;
     for (const [existingKey, existingValue] of snapshot(this.map)) {
@@ -132,4 +140,4 @@ export {
   setCaseInsensitiveFileIndex,
   unsetCaseInsensitiveFileIndex
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/case-insensitive-file-index.ts"],"sourcesContent":["/**\n * @file\n *\n * Provides an opt-in O(1) case-insensitive resolver for Obsidian vaults.\n *\n * Obsidian's native {@link https://docs.obsidian.md/Reference/TypeScript+API/Vault | Vault} resolves\n * a string path case-insensitively (the Windows/macOS default) in O(1) on a hit but with an\n * O(vault) scan on a miss. The miss case is the hot one during deletion cascades, where extension\n * checks and cache lookups are performed on already-removed paths. This module backs the\n * case-insensitive lookup with a `lowercase-path → TAbstractFile` index so misses are O(1) too.\n *\n * The index is explicitly opt-in: a consumer installs it by loading a\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/Component | Component} that keeps it in\n * sync with `create`/`delete`/`rename` events (see `CaseInsensitiveFileIndexComponent`). Until then,\n * the resolution layer falls back to the native (O(vault)-on-miss) lookup, so behavior is unchanged.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\n\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\nconst STATE_KEY = 'caseInsensitiveFileIndex';\n\n/**\n * An O(1) case-insensitive index of the loaded files and folders of a single vault.\n *\n * The index maps the lowercased path of each abstract file to the abstract file itself. It is kept\n * in sync by an owning component that forwards `create`/`delete`/`rename` vault events.\n */\nexport class CaseInsensitiveFileIndex {\n  private readonly map = new Map<string, TAbstractFile>();\n\n  /**\n   * Creates a new case-insensitive file index.\n   *\n   * @param app - The Obsidian application instance whose vault this index mirrors.\n   */\n  public constructor(protected readonly app: App) {}\n\n  /**\n   * Adds an abstract file to the index.\n   *\n   * @param abstractFile - The abstract file to add.\n   */\n  public add(abstractFile: TAbstractFile): void {\n    this.map.set(abstractFile.path.toLowerCase(), abstractFile);\n  }\n\n  /**\n   * Removes the abstract file at the given path from the index, along with all of its descendants\n   * (for folder deletions, where Obsidian removes the whole subtree).\n   *\n   * @param path - The path of the abstract file to remove.\n   */\n  public delete(path: string): void {\n    const key = path.toLowerCase();\n    this.map.delete(key);\n    const descendantPrefix = `${key}/`;\n    for (const existingKey of snapshot(this.map.keys())) {\n      if (existingKey.startsWith(descendantPrefix)) {\n        this.map.delete(existingKey);\n      }\n    }\n  }\n\n  /**\n   * Resolves an abstract file by its path, case-insensitively, in O(1).\n   *\n   * @param path - The path to resolve.\n   * @returns The abstract file if found, otherwise `null`.\n   */\n  public get(path: string): null | TAbstractFile {\n    return this.map.get(path.toLowerCase()) ?? null;\n  }\n\n  /**\n   * Checks whether this index mirrors the given application's vault.\n   *\n   * @param app - The application instance to check against.\n   * @returns `true` if this index belongs to the given application, `false` otherwise.\n   */\n  public ownsApp(app: App): boolean {\n    return this.app === app;\n  }\n\n  /**\n   * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.\n   *\n   * Obsidian fires a single `rename` event for the renamed abstract file and updates its\n   * descendants' paths in place without firing per-descendant events, so descendant keys are\n   * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the\n   * old and new keys coincide).\n   *\n   * @param oldPath - The path the abstract file had before the rename.\n   * @param newAbstractFile - The abstract file with its updated (post-rename) path.\n   */\n  public rename(oldPath: string, newAbstractFile: TAbstractFile): void {\n    const oldKey = oldPath.toLowerCase();\n    const newKey = newAbstractFile.path.toLowerCase();\n    this.map.delete(oldKey);\n    this.map.set(newKey, newAbstractFile);\n\n    const oldDescendantPrefix = `${oldKey}/`;\n    const newDescendantPrefix = `${newKey}/`;\n    for (const [existingKey, existingValue] of snapshot(this.map)) {\n      if (!existingKey.startsWith(oldDescendantPrefix)) {\n        continue;\n      }\n\n      this.map.delete(existingKey);\n      this.map.set(newDescendantPrefix + existingKey.slice(oldDescendantPrefix.length), existingValue);\n    }\n  }\n}\n\n/**\n * Retrieves the installed case-insensitive file index for the given application, if any.\n *\n * @param app - The application instance whose index to retrieve.\n * @returns The index if one is installed for this application, otherwise `null`.\n */\nexport function getCaseInsensitiveFileIndex(app: App): CaseInsensitiveFileIndex | null {\n  const index = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value;\n  return index?.ownsApp(app) ? index : null;\n}\n\n/**\n * Installs a case-insensitive file index as the active resolver.\n *\n * @param index - The index to install.\n */\nexport function setCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value = index;\n}\n\n/**\n * Uninstalls a case-insensitive file index, but only if it is the currently-installed one.\n *\n * @param index - The index to uninstall.\n */\nexport function unsetCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  const wrapper = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null);\n  if (wrapper.value === index) {\n    wrapper.value = null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,gBAAgB;AAEzB,SAAS,2BAA2B;AAEpC,MAAM,YAAY;AAQX,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ7B,YAA+B,KAAU;AAAV;AAAA,EAAW;AAAA,EAAX;AAAA,EAPrB,MAAM,oBAAI,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc/C,IAAI,cAAmC;AAC5C,SAAK,IAAI,IAAI,aAAa,KAAK,YAAY,GAAG,YAAY;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,MAAoB;AAChC,UAAM,MAAM,KAAK,YAAY;AAC7B,SAAK,IAAI,OAAO,GAAG;AACnB,UAAM,mBAAmB,GAAG,GAAG;AAC/B,eAAW,eAAe,SAAS,KAAK,IAAI,KAAK,CAAC,GAAG;AACnD,UAAI,YAAY,WAAW,gBAAgB,GAAG;AAC5C,aAAK,IAAI,OAAO,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,MAAoC;AAC7C,WAAO,KAAK,IAAI,IAAI,KAAK,YAAY,CAAC,KAAK;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,KAAmB;AAChC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,OAAO,SAAiB,iBAAsC;AACnE,UAAM,SAAS,QAAQ,YAAY;AACnC,UAAM,SAAS,gBAAgB,KAAK,YAAY;AAChD,SAAK,IAAI,OAAO,MAAM;AACtB,SAAK,IAAI,IAAI,QAAQ,eAAe;AAEpC,UAAM,sBAAsB,GAAG,MAAM;AACrC,UAAM,sBAAsB,GAAG,MAAM;AACrC,eAAW,CAAC,aAAa,aAAa,KAAK,SAAS,KAAK,GAAG,GAAG;AAC7D,UAAI,CAAC,YAAY,WAAW,mBAAmB,GAAG;AAChD;AAAA,MACF;AAEA,WAAK,IAAI,OAAO,WAAW;AAC3B,WAAK,IAAI,IAAI,sBAAsB,YAAY,MAAM,oBAAoB,MAAM,GAAG,aAAa;AAAA,IACjG;AAAA,EACF;AACF;AAQO,SAAS,4BAA4B,KAA2C;AACrF,QAAM,QAAQ,oBAAqD,WAAW,IAAI,EAAE;AACpF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,sBAAqD,WAAW,IAAI,EAAE,QAAQ;AAChF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,UAAU,oBAAqD,WAAW,IAAI;AACpF,MAAI,QAAQ,UAAU,OAAO;AAC3B,YAAQ,QAAQ;AAAA,EAClB;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/case-insensitive-file-index.ts"],"sourcesContent":["/**\n * @file\n *\n * Provides an opt-in O(1) case-insensitive resolver for Obsidian vaults.\n *\n * Obsidian's native {@link https://docs.obsidian.md/Reference/TypeScript+API/Vault | Vault} resolves\n * a string path case-insensitively (the Windows/macOS default) in O(1) on a hit but with an\n * O(vault) scan on a miss. The miss case is the hot one during deletion cascades, where extension\n * checks and cache lookups are performed on already-removed paths. This module backs the\n * case-insensitive lookup with a `lowercase-path → TAbstractFile` index so misses are O(1) too.\n *\n * The index is explicitly opt-in: a consumer installs it by loading a\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/Component | Component} that keeps it in\n * sync with `create`/`delete`/`rename` events (see `CaseInsensitiveFileIndexComponent`). Until then,\n * the resolution layer falls back to the native (O(vault)-on-miss) lookup, so behavior is unchanged.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { TFolder } from 'obsidian';\n\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\nconst STATE_KEY = 'caseInsensitiveFileIndex';\n\n/**\n * An O(1) case-insensitive index of the loaded files and folders of a single vault.\n *\n * The index maps the lowercased path of each abstract file to the abstract file itself. It is kept\n * in sync by an owning component that forwards `create`/`delete`/`rename` vault events.\n */\nexport class CaseInsensitiveFileIndex {\n  private readonly map = new Map<string, TAbstractFile>();\n\n  /**\n   * Creates a new case-insensitive file index.\n   *\n   * @param app - The Obsidian application instance whose vault this index mirrors.\n   */\n  public constructor(protected readonly app: App) {}\n\n  /**\n   * Adds an abstract file to the index.\n   *\n   * @param abstractFile - The abstract file to add.\n   */\n  public add(abstractFile: TAbstractFile): void {\n    this.map.set(abstractFile.path.toLowerCase(), abstractFile);\n  }\n\n  /**\n   * Removes the abstract file at the given path from the index, along with all of its descendants\n   * (for folder deletions, where Obsidian removes the whole subtree).\n   *\n   * @param path - The path of the abstract file to remove.\n   */\n  public delete(path: string): void {\n    const key = path.toLowerCase();\n    const abstractFile = this.map.get(key);\n    this.map.delete(key);\n    // Only a folder has descendants; scanning the whole index for a file's made every delete O(vault).\n    if (abstractFile && !(abstractFile instanceof TFolder)) {\n      return;\n    }\n    const descendantPrefix = `${key}/`;\n    for (const existingKey of snapshot(this.map.keys())) {\n      if (existingKey.startsWith(descendantPrefix)) {\n        this.map.delete(existingKey);\n      }\n    }\n  }\n\n  /**\n   * Resolves an abstract file by its path, case-insensitively, in O(1).\n   *\n   * @param path - The path to resolve.\n   * @returns The abstract file if found, otherwise `null`.\n   */\n  public get(path: string): null | TAbstractFile {\n    return this.map.get(path.toLowerCase()) ?? null;\n  }\n\n  /**\n   * Checks whether this index mirrors the given application's vault.\n   *\n   * @param app - The application instance to check against.\n   * @returns `true` if this index belongs to the given application, `false` otherwise.\n   */\n  public ownsApp(app: App): boolean {\n    return this.app === app;\n  }\n\n  /**\n   * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.\n   *\n   * Obsidian fires a single `rename` event for the renamed abstract file and updates its\n   * descendants' paths in place without firing per-descendant events, so descendant keys are\n   * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the\n   * old and new keys coincide).\n   *\n   * @param oldPath - The path the abstract file had before the rename.\n   * @param newAbstractFile - The abstract file with its updated (post-rename) path.\n   */\n  public rename(oldPath: string, newAbstractFile: TAbstractFile): void {\n    const oldKey = oldPath.toLowerCase();\n    const newKey = newAbstractFile.path.toLowerCase();\n    this.map.delete(oldKey);\n    this.map.set(newKey, newAbstractFile);\n    // Only a folder has descendants; scanning the whole index for a file's made every rename O(vault).\n    if (!(newAbstractFile instanceof TFolder)) {\n      return;\n    }\n\n    const oldDescendantPrefix = `${oldKey}/`;\n    const newDescendantPrefix = `${newKey}/`;\n    for (const [existingKey, existingValue] of snapshot(this.map)) {\n      if (!existingKey.startsWith(oldDescendantPrefix)) {\n        continue;\n      }\n\n      this.map.delete(existingKey);\n      this.map.set(newDescendantPrefix + existingKey.slice(oldDescendantPrefix.length), existingValue);\n    }\n  }\n}\n\n/**\n * Retrieves the installed case-insensitive file index for the given application, if any.\n *\n * @param app - The application instance whose index to retrieve.\n * @returns The index if one is installed for this application, otherwise `null`.\n */\nexport function getCaseInsensitiveFileIndex(app: App): CaseInsensitiveFileIndex | null {\n  const index = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value;\n  return index?.ownsApp(app) ? index : null;\n}\n\n/**\n * Installs a case-insensitive file index as the active resolver.\n *\n * @param index - The index to install.\n */\nexport function setCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value = index;\n}\n\n/**\n * Uninstalls a case-insensitive file index, but only if it is the currently-installed one.\n *\n * @param index - The index to uninstall.\n */\nexport function unsetCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  const wrapper = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null);\n  if (wrapper.value === index) {\n    wrapper.value = null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,gBAAgB;AACzB,SAAS,eAAe;AAExB,SAAS,2BAA2B;AAEpC,MAAM,YAAY;AAQX,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ7B,YAA+B,KAAU;AAAV;AAAA,EAAW;AAAA,EAAX;AAAA,EAPrB,MAAM,oBAAI,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc/C,IAAI,cAAmC;AAC5C,SAAK,IAAI,IAAI,aAAa,KAAK,YAAY,GAAG,YAAY;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,MAAoB;AAChC,UAAM,MAAM,KAAK,YAAY;AAC7B,UAAM,eAAe,KAAK,IAAI,IAAI,GAAG;AACrC,SAAK,IAAI,OAAO,GAAG;AAEnB,QAAI,gBAAgB,EAAE,wBAAwB,UAAU;AACtD;AAAA,IACF;AACA,UAAM,mBAAmB,GAAG,GAAG;AAC/B,eAAW,eAAe,SAAS,KAAK,IAAI,KAAK,CAAC,GAAG;AACnD,UAAI,YAAY,WAAW,gBAAgB,GAAG;AAC5C,aAAK,IAAI,OAAO,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,MAAoC;AAC7C,WAAO,KAAK,IAAI,IAAI,KAAK,YAAY,CAAC,KAAK;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,KAAmB;AAChC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,OAAO,SAAiB,iBAAsC;AACnE,UAAM,SAAS,QAAQ,YAAY;AACnC,UAAM,SAAS,gBAAgB,KAAK,YAAY;AAChD,SAAK,IAAI,OAAO,MAAM;AACtB,SAAK,IAAI,IAAI,QAAQ,eAAe;AAEpC,QAAI,EAAE,2BAA2B,UAAU;AACzC;AAAA,IACF;AAEA,UAAM,sBAAsB,GAAG,MAAM;AACrC,UAAM,sBAAsB,GAAG,MAAM;AACrC,eAAW,CAAC,aAAa,aAAa,KAAK,SAAS,KAAK,GAAG,GAAG;AAC7D,UAAI,CAAC,YAAY,WAAW,mBAAmB,GAAG;AAChD;AAAA,MACF;AAEA,WAAK,IAAI,OAAO,WAAW;AAC3B,WAAK,IAAI,IAAI,sBAAsB,YAAY,MAAM,oBAAoB,MAAM,GAAG,aAAa;AAAA,IACjG;AAAA,EACF;AACF;AAQO,SAAS,4BAA4B,KAA2C;AACrF,QAAM,QAAQ,oBAAqD,WAAW,IAAI,EAAE;AACpF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,sBAAqD,WAAW,IAAI,EAAE,QAAQ;AAChF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,UAAU,oBAAqD,WAAW,IAAI;AACpF,MAAI,QAAQ,UAAU,OAAO;AAC3B,YAAQ,QAAQ;AAAA,EAClB;AACF;","names":[]}

package/dist/lib/esm/code-block-render-handoff.d.mts

@@ -0,0 +1,131 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Carries focus and plugin state from a code block to its next render.
+ *
+ * Obsidian renders a code block again whenever its source text changes: Reading view re-renders the section and Live
+ * Preview replaces the widget. So a block that edits its own source (a counter, a checkbox, a settings form) loses the
+ * element the user was interacting with, its focus and whatever the plugin kept on it. The element itself cannot be
+ * kept without patching Obsidian's renderers, so the write records a handoff instead, and the processor rendering the
+ * new source claims it: it gets back the state the write passed and can put the focus back on the same element.
+ *
+ * The handoff is matched by source path, language and the new block content, and it lives for
+ * {@link CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS}. The first render to claim it consumes it, so when the
+ * note is open in two panes only one of the new renders gets it.
+ */
+import type { MarkdownPostProcessorContext } from 'obsidian';
+/**
+ * How long a recorded handoff waits for the render that claims it.
+ */
+export declare const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 10000;
+/**
+ * Options for {@link claimCodeBlockRenderHandoff}.
+ */
+export interface ClaimCodeBlockRenderHandoffParams {
+    /**
+     * The {@link MarkdownPostProcessorContext} the processor received.
+     */
+    readonly context: MarkdownPostProcessorContext;
+    /**
+     * The element the processor renders into.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The source the processor received.
+     */
+    readonly source: string;
+}
+/**
+ * Where the focus was inside a rendered code block.
+ */
+export interface CodeBlockFocusSnapshot {
+    /**
+     * The child indices leading from the code block element to the focused element.
+     */
+    readonly childIndexPath: readonly number[];
+    /**
+     * The text selection of a focused input or text area.
+     */
+    readonly selection: null | TextSelection;
+}
+/**
+ * A handoff claimed by the render of a code block whose source a write just changed.
+ */
+export interface CodeBlockRenderHandoff {
+    /**
+     * Whether the write recorded a focused element to restore.
+     */
+    readonly hasFocus: boolean;
+    /**
+     * Puts the focus back on the element at the same position inside the new render, with the same text selection.
+     *
+     * Call it once the processor has rendered the block. It waits for the element to be attached to a document.
+     *
+     * @returns Whether an element was focused.
+     */
+    readonly restoreFocus: () => Promise<boolean>;
+    /**
+     * The state passed to the write, or `undefined` when none was.
+     */
+    readonly state: unknown;
+}
+/**
+ * Options for {@link recordCodeBlockRenderHandoff}.
+ */
+export interface RecordCodeBlockRenderHandoffParams {
+    /**
+     * The focus captured from the old render with {@link captureCodeBlockFocus}.
+     */
+    readonly focus: CodeBlockFocusSnapshot | null;
+    /**
+     * The code block written to the note, fences included.
+     */
+    readonly newCodeBlock: string;
+    /**
+     * The path of the note the code block is in.
+     */
+    readonly sourcePath: string;
+    /**
+     * The state to pass to the next render.
+     */
+    readonly state: unknown;
+}
+interface TextSelection {
+    readonly direction: 'backward' | 'forward' | 'none';
+    readonly end: number;
+    readonly start: number;
+}
+/**
+ * Captures where the focus is inside a rendered code block.
+ *
+ * @param el - The code block element.
+ * @returns The snapshot, or `null` when the focus is not inside the element.
+ */
+export declare function captureCodeBlockFocus(el: HTMLElement): CodeBlockFocusSnapshot | null;
+/**
+ * Claims the handoff a write recorded for the code block being rendered.
+ *
+ * Call it from a code block processor. It returns `null` when no write is waiting for this render.
+ *
+ * @param params - The parameters for the function.
+ * @returns The handoff, or `null`.
+ */
+export declare function claimCodeBlockRenderHandoff(params: ClaimCodeBlockRenderHandoffParams): CodeBlockRenderHandoff | null;
+/**
+ * Records a handoff for the next render of a code block a write is about to change.
+ *
+ * @param params - The parameters for the function.
+ * @returns Whether a handoff was recorded: `false` when the new text is not exactly one code block.
+ */
+export declare function recordCodeBlockRenderHandoff(params: RecordCodeBlockRenderHandoffParams): boolean;
+/**
+ * Puts the focus back on the element a {@link CodeBlockFocusSnapshot} describes.
+ *
+ * @param el - The new code block element.
+ * @param focus - The snapshot captured from the old render.
+ * @returns Whether an element was focused.
+ */
+export declare function restoreCodeBlockFocus(el: HTMLElement, focus: CodeBlockFocusSnapshot): Promise<boolean>;
+export {};

package/dist/lib/esm/code-block-render-handoff.mjs

@@ -0,0 +1,183 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { requestAnimationFrameAsync } from "@mnaoumov/typescript-lib/async";
+import {
+  getMandatoryNamedGroup,
+  getOptionalNamedGroup
+} from "@mnaoumov/typescript-lib/reg-exp";
+import { ensureLfEndings } from "@mnaoumov/typescript-lib/string";
+import { createCodeBlockRegExp } from "./code-block-reg-exp.mjs";
+import { getObsidianLibState } from "./obsidian-lib-state.mjs";
+const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 1e4;
+const HANDOFF_STATE_KEY = "codeBlockRenderHandoffV1";
+const MAX_FRAMES_TO_WAIT_FOR_CONNECTION = 60;
+function captureCodeBlockFocus(el) {
+  const activeElement = el.ownerDocument.activeElement;
+  if (!activeElement || activeElement === el || !el.contains(activeElement)) {
+    return null;
+  }
+  const childIndexPath = [];
+  let current = activeElement;
+  while (current && current !== el) {
+    let index = 0;
+    for (let sibling = current.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+      index++;
+    }
+    childIndexPath.unshift(index);
+    current = current.parentElement;
+  }
+  return {
+    childIndexPath,
+    selection: getTextSelection(activeElement)
+  };
+}
+function claimCodeBlockRenderHandoff(params) {
+  const { context, el, source } = params;
+  const entries = getHandoffEntries();
+  pruneExpiredEntries(entries);
+  const key = getHandoffKey(context.sourcePath, getLanguageFromElement(el), ensureLfEndings(source));
+  const queue = entries.get(key);
+  const entry = queue?.shift();
+  if (!queue || !entry) {
+    return null;
+  }
+  if (queue.length === 0) {
+    entries.delete(key);
+  }
+  return {
+    hasFocus: entry.focus !== null,
+    async restoreFocus() {
+      return entry.focus ? await restoreCodeBlockFocus(el, entry.focus) : false;
+    },
+    state: entry.state
+  };
+}
+function recordCodeBlockRenderHandoff(params) {
+  const { focus, newCodeBlock, sourcePath, state } = params;
+  const matches = [...ensureLfEndings(newCodeBlock).matchAll(createCodeBlockRegExp())];
+  const match = matches[0];
+  if (matches.length !== 1 || !match) {
+    return false;
+  }
+  const linePrefix = getMandatoryNamedGroup(match, "LinePrefix");
+  const language = getMandatoryNamedGroup(match, "CodeBlockLanguage");
+  const content = (getOptionalNamedGroup(match, "CodeBlockContent") ?? "").split("\n").map((line) => line.slice(linePrefix.length)).join("\n");
+  const entries = getHandoffEntries();
+  pruneExpiredEntries(entries);
+  const key = getHandoffKey(sourcePath, language, content);
+  let queue = entries.get(key);
+  if (!queue) {
+    queue = [];
+    entries.set(key, queue);
+  }
+  queue.push({
+    expiresAt: Date.now() + CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,
+    focus,
+    state
+  });
+  return true;
+}
+async function restoreCodeBlockFocus(el, focus) {
+  for (let frame = 0; !el.isConnected && frame < MAX_FRAMES_TO_WAIT_FOR_CONNECTION; frame++) {
+    await requestAnimationFrameAsync();
+  }
+  if (!el.isConnected) {
+    return false;
+  }
+  let target = el;
+  for (const index of focus.childIndexPath) {
+    target = target.children[index];
+    if (!target) {
+      return false;
+    }
+  }
+  if (!isHTMLElementLike(target)) {
+    return false;
+  }
+  target.focus({ preventScroll: true });
+  if (el.ownerDocument.activeElement !== target) {
+    return false;
+  }
+  if (focus.selection && isTextSelectionElement(target)) {
+    target.setSelectionRange(focus.selection.start, focus.selection.end, focus.selection.direction);
+  }
+  return true;
+}
+function getHandoffEntries() {
+  return getObsidianLibState(HANDOFF_STATE_KEY, /* @__PURE__ */ new Map()).value;
+}
+function getHandoffKey(sourcePath, language, content) {
+  return JSON.stringify([sourcePath, language, content]);
+}
+function getLanguageFromElement(element) {
+  const BLOCK_LANGUAGE_PREFIX = "block-language-";
+  return [...element.classList].find((cls) => cls.startsWith(BLOCK_LANGUAGE_PREFIX))?.slice(BLOCK_LANGUAGE_PREFIX.length) ?? "";
+}
+function getTextSelection(element) {
+  if (!isTextSelectionElement(element)) {
+    return null;
+  }
+  if (element.selectionStart === null || element.selectionEnd === null) {
+    return null;
+  }
+  return {
+    direction: element.selectionDirection ?? "none",
+    end: element.selectionEnd,
+    start: element.selectionStart
+  };
+}
+function isHTMLElementLike(element) {
+  return typeof element.focus === "function";
+}
+function isTextSelectionElement(element) {
+  return element.tagName === "INPUT" || element.tagName === "TEXTAREA";
+}
+function pruneExpiredEntries(entries) {
+  const now = Date.now();
+  for (const [key, queue] of entries) {
+    const liveEntries = queue.filter((entry) => entry.expiresAt > now);
+    if (liveEntries.length === 0) {
+      entries.delete(key);
+    } else if (liveEntries.length !== queue.length) {
+      entries.set(key, liveEntries);
+    }
+  }
+}
+export {
+  CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,
+  captureCodeBlockFocus,
+  claimCodeBlockRenderHandoff,
+  recordCodeBlockRenderHandoff,
+  restoreCodeBlockFocus
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/code-block-render-handoff.ts"],"sourcesContent":["/**\n * @file\n *\n * Carries focus and plugin state from a code block to its next render.\n *\n * Obsidian renders a code block again whenever its source text changes: Reading view re-renders the section and Live\n * Preview replaces the widget. So a block that edits its own source (a counter, a checkbox, a settings form) loses the\n * element the user was interacting with, its focus and whatever the plugin kept on it. The element itself cannot be\n * kept without patching Obsidian's renderers, so the write records a handoff instead, and the processor rendering the\n * new source claims it: it gets back the state the write passed and can put the focus back on the same element.\n *\n * The handoff is matched by source path, language and the new block content, and it lives for\n * {@link CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS}. The first render to claim it consumes it, so when the\n * note is open in two panes only one of the new renders gets it.\n */\n\nimport type { MarkdownPostProcessorContext } from 'obsidian';\n\nimport { requestAnimationFrameAsync } from '@mnaoumov/typescript-lib/async';\nimport {\n  getMandatoryNamedGroup,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { ensureLfEndings } from '@mnaoumov/typescript-lib/string';\n\nimport { createCodeBlockRegExp } from './code-block-reg-exp.ts';\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\n/**\n * How long a recorded handoff waits for the render that claims it.\n */\nexport const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 10_000;\n\nconst HANDOFF_STATE_KEY = 'codeBlockRenderHandoffV1';\nconst MAX_FRAMES_TO_WAIT_FOR_CONNECTION = 60;\n\n/**\n * Options for {@link claimCodeBlockRenderHandoff}.\n */\nexport interface ClaimCodeBlockRenderHandoffParams {\n  /**\n   * The {@link MarkdownPostProcessorContext} the processor received.\n   */\n  readonly context: MarkdownPostProcessorContext;\n\n  /**\n   * The element the processor renders into.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The source the processor received.\n   */\n  readonly source: string;\n}\n\n/**\n * Where the focus was inside a rendered code block.\n */\nexport interface CodeBlockFocusSnapshot {\n  /**\n   * The child indices leading from the code block element to the focused element.\n   */\n  readonly childIndexPath: readonly number[];\n\n  /**\n   * The text selection of a focused input or text area.\n   */\n  readonly selection: null | TextSelection;\n}\n\n/**\n * A handoff claimed by the render of a code block whose source a write just changed.\n */\nexport interface CodeBlockRenderHandoff {\n  /**\n   * Whether the write recorded a focused element to restore.\n   */\n  readonly hasFocus: boolean;\n\n  /**\n   * Puts the focus back on the element at the same position inside the new render, with the same text selection.\n   *\n   * Call it once the processor has rendered the block. It waits for the element to be attached to a document.\n   *\n   * @returns Whether an element was focused.\n   */\n  readonly restoreFocus: () => Promise<boolean>;\n\n  /**\n   * The state passed to the write, or `undefined` when none was.\n   */\n  readonly state: unknown;\n}\n\n/**\n * Options for {@link recordCodeBlockRenderHandoff}.\n */\nexport interface RecordCodeBlockRenderHandoffParams {\n  /**\n   * The focus captured from the old render with {@link captureCodeBlockFocus}.\n   */\n  readonly focus: CodeBlockFocusSnapshot | null;\n\n  /**\n   * The code block written to the note, fences included.\n   */\n  readonly newCodeBlock: string;\n\n  /**\n   * The path of the note the code block is in.\n   */\n  readonly sourcePath: string;\n\n  /**\n   * The state to pass to the next render.\n   */\n  readonly state: unknown;\n}\n\ninterface HandoffEntry {\n  readonly expiresAt: number;\n  readonly focus: CodeBlockFocusSnapshot | null;\n  readonly state: unknown;\n}\n\ninterface TextSelection {\n  readonly direction: 'backward' | 'forward' | 'none';\n  readonly end: number;\n  readonly start: number;\n}\n\ninterface TextSelectionElement extends HTMLElement {\n  readonly selectionDirection: 'backward' | 'forward' | 'none' | null;\n  readonly selectionEnd: null | number;\n  readonly selectionStart: null | number;\n  readonly setSelectionRange: (start: number, end: number, direction?: 'backward' | 'forward' | 'none') => void;\n}\n\n/**\n * Captures where the focus is inside a rendered code block.\n *\n * @param el - The code block element.\n * @returns The snapshot, or `null` when the focus is not inside the element.\n */\nexport function captureCodeBlockFocus(el: HTMLElement): CodeBlockFocusSnapshot | null {\n  const activeElement = el.ownerDocument.activeElement;\n  if (!activeElement || activeElement === el || !el.contains(activeElement)) {\n    return null;\n  }\n\n  const childIndexPath: number[] = [];\n  let current: Element | null = activeElement;\n  while (current && current !== el) {\n    let index = 0;\n    for (let sibling = current.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {\n      index++;\n    }\n    childIndexPath.unshift(index);\n    current = current.parentElement;\n  }\n\n  return {\n    childIndexPath,\n    selection: getTextSelection(activeElement)\n  };\n}\n\n/**\n * Claims the handoff a write recorded for the code block being rendered.\n *\n * Call it from a code block processor. It returns `null` when no write is waiting for this render.\n *\n * @param params - The parameters for the function.\n * @returns The handoff, or `null`.\n */\nexport function claimCodeBlockRenderHandoff(params: ClaimCodeBlockRenderHandoffParams): CodeBlockRenderHandoff | null {\n  const { context, el, source } = params;\n  const entries = getHandoffEntries();\n  pruneExpiredEntries(entries);\n\n  const key = getHandoffKey(context.sourcePath, getLanguageFromElement(el), ensureLfEndings(source));\n  const queue = entries.get(key);\n  const entry = queue?.shift();\n  if (!queue || !entry) {\n    return null;\n  }\n\n  if (queue.length === 0) {\n    entries.delete(key);\n  }\n\n  return {\n    hasFocus: entry.focus !== null,\n    async restoreFocus(): Promise<boolean> {\n      return entry.focus ? (await restoreCodeBlockFocus(el, entry.focus)) : false;\n    },\n    state: entry.state\n  };\n}\n\n/**\n * Records a handoff for the next render of a code block a write is about to change.\n *\n * @param params - The parameters for the function.\n * @returns Whether a handoff was recorded: `false` when the new text is not exactly one code block.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- A verb names the action; the boolean only reports whether it took place.\nexport function recordCodeBlockRenderHandoff(params: RecordCodeBlockRenderHandoffParams): boolean {\n  const { focus, newCodeBlock, sourcePath, state } = params;\n  const matches = [...ensureLfEndings(newCodeBlock).matchAll(createCodeBlockRegExp())];\n  const match = matches[0];\n  if (matches.length !== 1 || !match) {\n    return false;\n  }\n\n  const linePrefix = getMandatoryNamedGroup(match, 'LinePrefix');\n  const language = getMandatoryNamedGroup(match, 'CodeBlockLanguage');\n  const content = (getOptionalNamedGroup(match, 'CodeBlockContent') ?? '').split('\\n').map((line) => line.slice(linePrefix.length)).join('\\n');\n\n  const entries = getHandoffEntries();\n  pruneExpiredEntries(entries);\n  const key = getHandoffKey(sourcePath, language, content);\n  let queue = entries.get(key);\n  if (!queue) {\n    queue = [];\n    entries.set(key, queue);\n  }\n  queue.push({\n    expiresAt: Date.now() + CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,\n    focus,\n    state\n  });\n  return true;\n}\n\n/**\n * Puts the focus back on the element a {@link CodeBlockFocusSnapshot} describes.\n *\n * @param el - The new code block element.\n * @param focus - The snapshot captured from the old render.\n * @returns Whether an element was focused.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- A verb names the action; the boolean only reports whether it took place.\nexport async function restoreCodeBlockFocus(el: HTMLElement, focus: CodeBlockFocusSnapshot): Promise<boolean> {\n  for (let frame = 0; !el.isConnected && frame < MAX_FRAMES_TO_WAIT_FOR_CONNECTION; frame++) {\n    await requestAnimationFrameAsync();\n  }\n\n  if (!el.isConnected) {\n    return false;\n  }\n\n  let target: Element | undefined = el;\n  for (const index of focus.childIndexPath) {\n    target = target.children[index];\n    if (!target) {\n      return false;\n    }\n  }\n\n  if (!isHTMLElementLike(target)) {\n    return false;\n  }\n\n  target.focus({ preventScroll: true });\n  if (el.ownerDocument.activeElement !== target) {\n    return false;\n  }\n\n  if (focus.selection && isTextSelectionElement(target)) {\n    target.setSelectionRange(focus.selection.start, focus.selection.end, focus.selection.direction);\n  }\n\n  return true;\n}\n\nfunction getHandoffEntries(): Map<string, HandoffEntry[]> {\n  return getObsidianLibState(HANDOFF_STATE_KEY, new Map<string, HandoffEntry[]>()).value;\n}\n\nfunction getHandoffKey(sourcePath: string, language: string, content: string): string {\n  return JSON.stringify([sourcePath, language, content]);\n}\n\nfunction getLanguageFromElement(element: HTMLElement): string {\n  const BLOCK_LANGUAGE_PREFIX = 'block-language-';\n  return [...element.classList].find((cls) => cls.startsWith(BLOCK_LANGUAGE_PREFIX))?.slice(BLOCK_LANGUAGE_PREFIX.length) ?? '';\n}\n\nfunction getTextSelection(element: Element): null | TextSelection {\n  if (!isTextSelectionElement(element)) {\n    return null;\n  }\n\n  // An input type without a text selection (a checkbox, a number field) reads `null` here.\n  if (element.selectionStart === null || element.selectionEnd === null) {\n    return null;\n  }\n\n  return {\n    direction: element.selectionDirection ?? 'none',\n    end: element.selectionEnd,\n    start: element.selectionStart\n  };\n}\n\nfunction isHTMLElementLike(element: Element): element is HTMLElement {\n  return typeof (element as Partial<HTMLElement>).focus === 'function';\n}\n\nfunction isTextSelectionElement(element: Element): element is TextSelectionElement {\n  return element.tagName === 'INPUT' || element.tagName === 'TEXTAREA';\n}\n\nfunction pruneExpiredEntries(entries: Map<string, HandoffEntry[]>): void {\n  const now = Date.now();\n  for (const [key, queue] of entries) {\n    const liveEntries = queue.filter((entry) => entry.expiresAt > now);\n    if (liveEntries.length === 0) {\n      entries.delete(key);\n    } else if (liveEntries.length !== queue.length) {\n      entries.set(key, liveEntries);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/codemirror/index.d.mts

@@ -1,5 +1,7 @@
 /// <reference path="../library-references.d.mts" />
 export * as 'incremental-parse-state-field' from './incremental-parse-state-field.mjs';
+export * as 'inline-token-widgets' from './inline-token-widgets.mjs';
 export * as 'markdown-editor-views' from './markdown-editor-views.mjs';
 export * as 'range-set' from './range-set.mjs';
+export * as 'settings-facet' from './settings-facet.mjs';
 export * as 'state-field-spec' from './state-field-spec.mjs';

package/dist/lib/esm/codemirror/index.mjs

@@ -4,13 +4,17 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 import * as incremental_parse_state_field from "./incremental-parse-state-field.mjs";
+import * as inline_token_widgets from "./inline-token-widgets.mjs";
 import * as markdown_editor_views from "./markdown-editor-views.mjs";
 import * as range_set from "./range-set.mjs";
+import * as settings_facet from "./settings-facet.mjs";
 import * as state_field_spec from "./state-field-spec.mjs";
 export {
   incremental_parse_state_field as "incremental-parse-state-field",
+  inline_token_widgets as "inline-token-widgets",
   markdown_editor_views as "markdown-editor-views",
   range_set as "range-set",
+  settings_facet as "settings-facet",
   state_field_spec as "state-field-spec"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvZGVtaXJyb3IvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQnIGZyb20gJy4vaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQudHMnO1xuZXhwb3J0ICogYXMgJ21hcmtkb3duLWVkaXRvci12aWV3cycgZnJvbSAnLi9tYXJrZG93bi1lZGl0b3Itdmlld3MudHMnO1xuZXhwb3J0ICogYXMgJ3JhbmdlLXNldCcgZnJvbSAnLi9yYW5nZS1zZXQudHMnO1xuZXhwb3J0ICogYXMgJ3N0YXRlLWZpZWxkLXNwZWMnIGZyb20gJy4vc3RhdGUtZmllbGQtc3BlYy50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVlBLG1DQUFxQztBQUNqRCxZQUFZQywyQkFBNkI7QUFDekMsWUFBWUMsZUFBaUI7QUFDN0IsWUFBWUMsc0JBQXdCOyIsCiAgIm5hbWVzIjogWyJpbmNyZW1lbnRhbC1wYXJzZS1zdGF0ZS1maWVsZCIsICJtYXJrZG93bi1lZGl0b3Itdmlld3MiLCAicmFuZ2Utc2V0IiwgInN0YXRlLWZpZWxkLXNwZWMiXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvZGVtaXJyb3IvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQnIGZyb20gJy4vaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQudHMnO1xuZXhwb3J0ICogYXMgJ2lubGluZS10b2tlbi13aWRnZXRzJyBmcm9tICcuL2lubGluZS10b2tlbi13aWRnZXRzLnRzJztcbmV4cG9ydCAqIGFzICdtYXJrZG93bi1lZGl0b3Itdmlld3MnIGZyb20gJy4vbWFya2Rvd24tZWRpdG9yLXZpZXdzLnRzJztcbmV4cG9ydCAqIGFzICdyYW5nZS1zZXQnIGZyb20gJy4vcmFuZ2Utc2V0LnRzJztcbmV4cG9ydCAqIGFzICdzZXR0aW5ncy1mYWNldCcgZnJvbSAnLi9zZXR0aW5ncy1mYWNldC50cyc7XG5leHBvcnQgKiBhcyAnc3RhdGUtZmllbGQtc3BlYycgZnJvbSAnLi9zdGF0ZS1maWVsZC1zcGVjLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsbUNBQXFDO0FBQ2pELFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQywyQkFBNkI7QUFDekMsWUFBWUMsZUFBaUI7QUFDN0IsWUFBWUMsb0JBQXNCO0FBQ2xDLFlBQVlDLHNCQUF3QjsiLAogICJuYW1lcyI6IFsiaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQiLCAiaW5saW5lLXRva2VuLXdpZGdldHMiLCAibWFya2Rvd24tZWRpdG9yLXZpZXdzIiwgInJhbmdlLXNldCIsICJzZXR0aW5ncy1mYWNldCIsICJzdGF0ZS1maWVsZC1zcGVjIl0KfQo=

package/dist/lib/esm/codemirror/inline-token-widgets.d.mts

@@ -0,0 +1,109 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Creates an editor extension that replaces every match of a regular expression with a widget in Live Preview, and
+ * shows the source again while a selection touches it, the way Obsidian treats its own links and formatting.
+ *
+ * Only the visible ranges are matched, line by line, so a token never spans two lines. The decorations are rebuilt
+ * when the document, the viewport, the selection, the Live Preview mode or the configuration changes; a
+ * configuration change is what a `SettingsFacetComponent` dispatches, so a render that reads a settings facet
+ * re-runs when the settings do.
+ *
+ * Outside an Obsidian Markdown editor there is no `editorLivePreviewField`, and the widgets are shown.
+ */
+import type { EditorState, Extension } from '@codemirror/state';
+/**
+ * Parameters for {@link createInlineTokenWidgetsExtension}.
+ */
+export interface CreateInlineTokenWidgetsExtensionParams {
+    /**
+     * The regular expression a token matches. The `g` flag is added when missing.
+     */
+    readonly regExp: RegExp;
+    /**
+     * Renders a token into the widget's element.
+     */
+    readonly render: InlineTokenRenderFunction;
+    /**
+     * Decides whether a match becomes a widget, such as to skip a match inside code. Every match does by default.
+     */
+    readonly shouldDecorate?: (params: InlineTokenShouldDecorateParams) => boolean;
+    /**
+     * Whether a token shows its source while a selection, the cursor included, touches it.
+     *
+     * @default `true`
+     */
+    readonly shouldRevealOnSelection?: boolean;
+}
+/**
+ * Renders an inline token into its container element.
+ *
+ * @param params - The render parameters.
+ */
+export type InlineTokenRenderFunction = (params: InlineTokenRenderParams) => void;
+/**
+ * Parameters handed to an inline token render function.
+ */
+export interface InlineTokenRenderParams {
+    /**
+     * The element to render the token into.
+     */
+    readonly containerEl: HTMLElement;
+    /**
+     * The match of the token's regular expression.
+     */
+    readonly match: RegExpExecArray;
+    /**
+     * The path of the note the token is in, or an empty string when it is not known.
+     */
+    readonly sourcePath: string;
+    /**
+     * The editor state, when the token renders in an editor. Absent in Reading view.
+     */
+    readonly state?: EditorState;
+}
+/**
+ * Parameters handed to {@link CreateInlineTokenWidgetsExtensionParams.shouldDecorate}.
+ */
+export interface InlineTokenShouldDecorateParams {
+    /**
+     * The document position the match starts at.
+     */
+    readonly from: number;
+    /**
+     * The match of the token's regular expression.
+     */
+    readonly match: RegExpExecArray;
+    /**
+     * The editor state.
+     */
+    readonly state: EditorState;
+    /**
+     * The document position the match ends at.
+     */
+    readonly to: number;
+}
+/**
+ * Creates an editor extension that replaces every match of a regular expression with a widget in Live Preview.
+ *
+ * @param params - The extension parameters.
+ * @returns The editor extension.
+ */
+export declare function createInlineTokenWidgetsExtension(params: CreateInlineTokenWidgetsExtensionParams): Extension;
+/**
+ * Lists every non-empty match of a global regular expression in a text.
+ *
+ * @param regExp - The global regular expression.
+ * @param text - The text to match.
+ * @returns The matches, in order.
+ */
+export declare function execAll(regExp: RegExp, text: string): RegExpExecArray[];
+/**
+ * Copies a regular expression with the `g` flag set, so matching never moves the caller's `lastIndex`.
+ *
+ * @param regExp - The regular expression.
+ * @returns A global copy of the regular expression.
+ */
+export declare function toGlobalRegExp(regExp: RegExp): RegExp;