@mnaoumov/obsidian-lib 10.5.0 → 10.6.0

package/dist/lib/esm/link-and-tag-input-suggest.mjs

@@ -0,0 +1,239 @@
+/*
+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 { castTo } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  AbstractInputSuggest,
+  getAllTags,
+  prepareFuzzySearch,
+  sortSearchResults
+} from "obsidian";
+var LinkAndTagCompletionKind = /* @__PURE__ */ ((LinkAndTagCompletionKind2) => {
+  LinkAndTagCompletionKind2["Link"] = "link";
+  LinkAndTagCompletionKind2["Tag"] = "tag";
+  return LinkAndTagCompletionKind2;
+})(LinkAndTagCompletionKind || {});
+const LINK_OPEN = "[[";
+const LINK_CLOSE = "]]";
+const TAG_PREFIX = "#";
+const TAG_BEFORE_CARET_REG_EXP = /(?:^|\s)#[\p{L}\p{N}_/-]*$/u;
+class LinkAndTagInputSuggest extends AbstractInputSuggest {
+  /**
+   * The element the suggest completes in.
+   */
+  inputEl;
+  /**
+   * Whether `[[` completes links.
+   */
+  shouldSuggestLinks;
+  /**
+   * Whether `#` completes tags.
+   */
+  shouldSuggestTags;
+  /**
+   * The path that inserted links are relative to.
+   */
+  sourcePath;
+  /**
+   * Creates the suggest and attaches it to the element.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super(params.app, castTo(params.inputEl));
+    this.inputEl = params.inputEl;
+    this.shouldSuggestLinks = params.shouldSuggestLinks ?? true;
+    this.shouldSuggestTags = params.shouldSuggestTags ?? true;
+    this.sourcePath = params.sourcePath ?? "";
+  }
+  /**
+   * Gets the value of the element.
+   *
+   * @returns The value.
+   */
+  getValue() {
+    return this.inputEl.value;
+  }
+  /**
+   * Renders a suggestion.
+   *
+   * @param suggestion - The suggestion.
+   * @param el - The element to render into.
+   */
+  renderSuggestion(suggestion, el) {
+    if (suggestion.kind === "link" /* Link */) {
+      el.createDiv({ cls: "suggestion-title", text: suggestion.linktext });
+      if (suggestion.linktext !== suggestion.file.path) {
+        el.createDiv({ cls: "suggestion-note", text: suggestion.file.path });
+      }
+      return;
+    }
+    el.addClass("mod-complex");
+    el.createDiv({ cls: "suggestion-content", text: `${TAG_PREFIX}${suggestion.tag}` });
+    el.createDiv({ cls: "suggestion-aux", text: String(suggestion.count) });
+  }
+  /**
+   * Inserts the suggestion in place of the trigger, moves the caret after it and dispatches an `input` event, so a
+   * component listening on the element sees the change.
+   *
+   * @param suggestion - The suggestion.
+   * @param $event - The event that selected it.
+   */
+  selectSuggestion(suggestion, $event) {
+    const trigger = this.getTrigger();
+    if (trigger) {
+      const value = this.getValue();
+      let after = value.slice(trigger.end);
+      let insertion;
+      if (suggestion.kind === "link" /* Link */) {
+        insertion = `${LINK_OPEN}${suggestion.linktext}${LINK_CLOSE}`;
+        if (after.startsWith(LINK_CLOSE)) {
+          after = after.slice(LINK_CLOSE.length);
+        }
+      } else {
+        insertion = `${TAG_PREFIX}${suggestion.tag} `;
+      }
+      this.setValue(value.slice(0, trigger.start) + insertion + after);
+      const caret = trigger.start + insertion.length;
+      this.inputEl.setSelectionRange(caret, caret);
+      this.inputEl.dispatchEvent(new Event("input", { bubbles: true }));
+    }
+    super.selectSuggestion(suggestion, $event);
+    this.close();
+  }
+  /**
+   * Sets the value of the element.
+   *
+   * @param value - The value.
+   */
+  setValue(value) {
+    this.inputEl.value = value;
+  }
+  /**
+   * Gets the link suggestions for a query.
+   *
+   * @param query - The text typed after `[[`.
+   * @returns The suggestions, best match first.
+   */
+  getLinkSuggestions(query) {
+    const fuzzySearch = prepareFuzzySearch(query);
+    const results = [];
+    for (const file of this.app.vault.getFiles()) {
+      const linktext = this.app.metadataCache.fileToLinktext(file, this.sourcePath, true);
+      const match = fuzzySearch(linktext) ?? fuzzySearch(file.path);
+      if (match) {
+        results.push({ match, suggestion: { file, kind: "link" /* Link */, linktext } });
+      }
+    }
+    sortSearchResults(results);
+    return results.map((result) => result.suggestion);
+  }
+  /**
+   * Gets the suggestions for the trigger before the caret. The query Obsidian passes is the whole value, so it is
+   * ignored.
+   *
+   * @returns The suggestions.
+   */
+  getSuggestions() {
+    const trigger = this.getTrigger();
+    if (trigger?.kind === "link" /* Link */) {
+      return this.getLinkSuggestions(trigger.query);
+    }
+    return trigger?.kind === "tag" /* Tag */ ? this.getTagSuggestions(trigger.query) : [];
+  }
+  /**
+   * Gets the tag suggestions for a query, from the tags of every note.
+   *
+   * @param query - The text typed after `#`.
+   * @returns The suggestions, best match first, then the most used.
+   */
+  getTagSuggestions(query) {
+    return getVaultTagSuggestions({ app: this.app, query });
+  }
+  /**
+   * Gets the enabled trigger before the caret.
+   *
+   * @returns The trigger, or `null`.
+   */
+  getTrigger() {
+    const value = this.getValue();
+    const trigger = getLinkAndTagCompletionTrigger(value, this.inputEl.selectionStart ?? value.length);
+    if (trigger?.kind === "link" /* Link */ && !this.shouldSuggestLinks) {
+      return null;
+    }
+    return trigger?.kind === "tag" /* Tag */ && !this.shouldSuggestTags ? null : trigger;
+  }
+}
+function getLinkAndTagCompletionTrigger(text, caret) {
+  const beforeCaret = text.slice(0, caret);
+  const linkStart = beforeCaret.lastIndexOf(LINK_OPEN);
+  if (linkStart !== -1) {
+    const query = beforeCaret.slice(linkStart + LINK_OPEN.length);
+    if (!query.includes(LINK_CLOSE) && !query.includes("\n") && !query.includes("|")) {
+      return { end: caret, kind: "link" /* Link */, query, start: linkStart };
+    }
+  }
+  if (TAG_BEFORE_CARET_REG_EXP.test(beforeCaret)) {
+    const start = beforeCaret.lastIndexOf(TAG_PREFIX);
+    return { end: caret, kind: "tag" /* Tag */, query: beforeCaret.slice(start + TAG_PREFIX.length), start };
+  }
+  return null;
+}
+function getVaultTagSuggestions(params) {
+  const { app, query } = params;
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of app.vault.getMarkdownFiles()) {
+    const cache = app.metadataCache.getFileCache(file);
+    for (const tag of (cache ? getAllTags(cache) : null) ?? []) {
+      const name = tag.slice(TAG_PREFIX.length);
+      counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+  }
+  const fuzzySearch = prepareFuzzySearch(query);
+  const results = [];
+  const sortedCounts = [...counts].sort(([tag1, count1], [tag2, count2]) => count2 - count1 || tag1.localeCompare(tag2));
+  for (const [tag, count] of sortedCounts) {
+    const match = fuzzySearch(tag);
+    if (match) {
+      results.push({ match, suggestion: { count, kind: "tag" /* Tag */, tag } });
+    }
+  }
+  sortSearchResults(results);
+  return results.map((result) => result.suggestion);
+}
+export {
+  LinkAndTagCompletionKind,
+  LinkAndTagInputSuggest,
+  getLinkAndTagCompletionTrigger,
+  getVaultTagSuggestions
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/link-and-tag-input-suggest.ts"],"sourcesContent":["/**\n * @file\n *\n * Completes `[[` links and `#` tags at the caret of any `<input>` or `<textarea>`, the way the editor does.\n */\n\nimport type {\n  App,\n  SearchResult,\n  TFile\n} from 'obsidian';\n\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  AbstractInputSuggest,\n  getAllTags,\n  prepareFuzzySearch,\n  sortSearchResults\n} from 'obsidian';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `TagListComponent` to use it in the tsdocs.\nimport type { TagListComponent } from './setting-components/tag-list-component.ts';\n\n/**\n * What a completion trigger completes.\n */\nexport enum LinkAndTagCompletionKind {\n  /**\n   * A `[[` wikilink to a vault file.\n   */\n  Link = 'link',\n\n  /**\n   * A `#` tag.\n   */\n  Tag = 'tag'\n}\n\n/**\n * A completion trigger found before the caret.\n */\nexport interface LinkAndTagCompletionTrigger {\n  /**\n   * The offset of the caret, where the query ends.\n   */\n  readonly end: number;\n\n  /**\n   * What the trigger completes.\n   */\n  readonly kind: LinkAndTagCompletionKind;\n\n  /**\n   * The text typed after the trigger characters.\n   */\n  readonly query: string;\n\n  /**\n   * The offset of the trigger characters: the first `[` of `[[`, or the `#`.\n   */\n  readonly start: number;\n}\n\n/**\n * Parameters of {@link LinkAndTagInputSuggest}.\n */\nexport interface LinkAndTagInputSuggestConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The element to complete in.\n   */\n  readonly inputEl: HTMLInputElement | HTMLTextAreaElement;\n\n  /**\n   * Whether `[[` completes links. Defaults to `true`.\n   */\n  readonly shouldSuggestLinks?: boolean;\n\n  /**\n   * Whether `#` completes tags. Defaults to `true`.\n   */\n  readonly shouldSuggestTags?: boolean;\n\n  /**\n   * The path that inserted links are relative to. Defaults to the vault root.\n   */\n  readonly sourcePath?: string;\n}\n\n/**\n * A suggestion of {@link LinkAndTagInputSuggest}.\n */\nexport type LinkAndTagSuggestion = LinkSuggestion | TagSuggestion;\n\n/**\n * A suggested link.\n */\nexport interface LinkSuggestion {\n  /**\n   * The file the link points to.\n   */\n  readonly file: TFile;\n\n  /**\n   * The kind of the suggestion.\n   */\n  readonly kind: LinkAndTagCompletionKind.Link;\n\n  /**\n   * The link text inserted between `[[` and `]]`.\n   */\n  readonly linktext: string;\n}\n\n/**\n * A suggested tag.\n */\nexport interface TagSuggestion {\n  /**\n   * How many tag occurrences the vault holds.\n   */\n  readonly count: number;\n\n  /**\n   * The kind of the suggestion.\n   */\n  readonly kind: LinkAndTagCompletionKind.Tag;\n\n  /**\n   * The tag, without its `#`.\n   */\n  readonly tag: string;\n}\n\ninterface SuggestionSearchResult<T> {\n  readonly match: SearchResult;\n  readonly suggestion: T;\n}\n\nconst LINK_OPEN = '[[';\nconst LINK_CLOSE = ']]';\nconst TAG_PREFIX = '#';\nconst TAG_BEFORE_CARET_REG_EXP = /(?:^|\\s)#[\\p{L}\\p{N}_/-]*$/u;\n\n/**\n * Parameters for {@link getVaultTagSuggestions}.\n */\nexport interface GetVaultTagSuggestionsParams {\n  /**\n   * The Obsidian app.\n   */\n  readonly app: App;\n\n  /**\n   * The text typed, without the `#`.\n   */\n  readonly query: string;\n}\n\n/**\n * Completes `[[` links and `#` tags inside any `<input>` or `<textarea>`.\n *\n * Obsidian's {@link AbstractInputSuggest} treats the whole value as the query and replaces it on selection. This one\n * reads the trigger before the caret and replaces only that, so it works inside free text such as a template or a\n * description setting, and it accepts a `<textarea>` too.\n *\n * ```ts\n * new Setting(containerEl).addTextArea((textArea) => {\n *   new LinkAndTagInputSuggest({ app: this.app, inputEl: textArea.inputEl });\n * });\n * ```\n */\nexport class LinkAndTagInputSuggest extends AbstractInputSuggest<LinkAndTagSuggestion> {\n  /**\n   * The element the suggest completes in.\n   */\n  protected readonly inputEl: HTMLInputElement | HTMLTextAreaElement;\n\n  /**\n   * Whether `[[` completes links.\n   */\n  protected readonly shouldSuggestLinks: boolean;\n\n  /**\n   * Whether `#` completes tags.\n   */\n  protected readonly shouldSuggestTags: boolean;\n\n  /**\n   * The path that inserted links are relative to.\n   */\n  protected readonly sourcePath: string;\n\n  /**\n   * Creates the suggest and attaches it to the element.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: LinkAndTagInputSuggestConstructorParams) {\n    // Obsidian's suggest reads the value only through `getValue` and `setValue`, both overridden here, so a textarea works too.\n    super(params.app, castTo<HTMLInputElement>(params.inputEl));\n    this.inputEl = params.inputEl;\n    this.shouldSuggestLinks = params.shouldSuggestLinks ?? true;\n    this.shouldSuggestTags = params.shouldSuggestTags ?? true;\n    this.sourcePath = params.sourcePath ?? '';\n  }\n\n  /**\n   * Gets the value of the element.\n   *\n   * @returns The value.\n   */\n  public override getValue(): string {\n    return this.inputEl.value;\n  }\n\n  /**\n   * Renders a suggestion.\n   *\n   * @param suggestion - The suggestion.\n   * @param el - The element to render into.\n   */\n  public renderSuggestion(suggestion: LinkAndTagSuggestion, el: HTMLElement): void {\n    if (suggestion.kind === LinkAndTagCompletionKind.Link) {\n      el.createDiv({ cls: 'suggestion-title', text: suggestion.linktext });\n      if (suggestion.linktext !== suggestion.file.path) {\n        el.createDiv({ cls: 'suggestion-note', text: suggestion.file.path });\n      }\n      return;\n    }\n\n    el.addClass('mod-complex');\n    el.createDiv({ cls: 'suggestion-content', text: `${TAG_PREFIX}${suggestion.tag}` });\n    el.createDiv({ cls: 'suggestion-aux', text: String(suggestion.count) });\n  }\n\n  /**\n   * Inserts the suggestion in place of the trigger, moves the caret after it and dispatches an `input` event, so a\n   * component listening on the element sees the change.\n   *\n   * @param suggestion - The suggestion.\n   * @param $event - The event that selected it.\n   */\n  public override selectSuggestion(suggestion: LinkAndTagSuggestion, $event: KeyboardEvent | MouseEvent): void {\n    const trigger = this.getTrigger();\n    if (trigger) {\n      const value = this.getValue();\n      let after = value.slice(trigger.end);\n      let insertion: string;\n      if (suggestion.kind === LinkAndTagCompletionKind.Link) {\n        insertion = `${LINK_OPEN}${suggestion.linktext}${LINK_CLOSE}`;\n        if (after.startsWith(LINK_CLOSE)) {\n          after = after.slice(LINK_CLOSE.length);\n        }\n      } else {\n        insertion = `${TAG_PREFIX}${suggestion.tag} `;\n      }\n\n      this.setValue(value.slice(0, trigger.start) + insertion + after);\n      const caret = trigger.start + insertion.length;\n      this.inputEl.setSelectionRange(caret, caret);\n      this.inputEl.dispatchEvent(new Event('input', { bubbles: true }));\n    }\n\n    super.selectSuggestion(suggestion, $event);\n    this.close();\n  }\n\n  /**\n   * Sets the value of the element.\n   *\n   * @param value - The value.\n   */\n  public override setValue(value: string): void {\n    this.inputEl.value = value;\n  }\n\n  /**\n   * Gets the link suggestions for a query.\n   *\n   * @param query - The text typed after `[[`.\n   * @returns The suggestions, best match first.\n   */\n  protected getLinkSuggestions(query: string): LinkSuggestion[] {\n    const fuzzySearch = prepareFuzzySearch(query);\n    const results: SuggestionSearchResult<LinkSuggestion>[] = [];\n    for (const file of this.app.vault.getFiles()) {\n      const linktext = this.app.metadataCache.fileToLinktext(file, this.sourcePath, true);\n      const match = fuzzySearch(linktext) ?? fuzzySearch(file.path);\n      if (match) {\n        results.push({ match, suggestion: { file, kind: LinkAndTagCompletionKind.Link, linktext } });\n      }\n    }\n    sortSearchResults(results);\n    return results.map((result) => result.suggestion);\n  }\n\n  /**\n   * Gets the suggestions for the trigger before the caret. The query Obsidian passes is the whole value, so it is\n   * ignored.\n   *\n   * @returns The suggestions.\n   */\n  protected override getSuggestions(): LinkAndTagSuggestion[] {\n    const trigger = this.getTrigger();\n    if (trigger?.kind === LinkAndTagCompletionKind.Link) {\n      return this.getLinkSuggestions(trigger.query);\n    }\n    return trigger?.kind === LinkAndTagCompletionKind.Tag ? this.getTagSuggestions(trigger.query) : [];\n  }\n\n  /**\n   * Gets the tag suggestions for a query, from the tags of every note.\n   *\n   * @param query - The text typed after `#`.\n   * @returns The suggestions, best match first, then the most used.\n   */\n  protected getTagSuggestions(query: string): TagSuggestion[] {\n    return getVaultTagSuggestions({ app: this.app, query });\n  }\n\n  /**\n   * Gets the enabled trigger before the caret.\n   *\n   * @returns The trigger, or `null`.\n   */\n  protected getTrigger(): LinkAndTagCompletionTrigger | null {\n    const value = this.getValue();\n    const trigger = getLinkAndTagCompletionTrigger(value, this.inputEl.selectionStart ?? value.length);\n    if (trigger?.kind === LinkAndTagCompletionKind.Link && !this.shouldSuggestLinks) {\n      return null;\n    }\n    return trigger?.kind === LinkAndTagCompletionKind.Tag && !this.shouldSuggestTags ? null : trigger;\n  }\n}\n\n/**\n * Finds the `[[` link or `#` tag being typed before the caret.\n *\n * A link trigger is an unclosed `[[` on the caret's line with no `|` after it, so an alias being typed is left alone. A\n * tag trigger is a `#` at the start of the text or after whitespace, followed only by tag characters.\n *\n * @param text - The text of the element.\n * @param caret - The offset of the caret.\n * @returns The trigger, or `null` when the caret is not in one.\n */\nexport function getLinkAndTagCompletionTrigger(text: string, caret: number): LinkAndTagCompletionTrigger | null {\n  const beforeCaret = text.slice(0, caret);\n  const linkStart = beforeCaret.lastIndexOf(LINK_OPEN);\n  if (linkStart !== -1) {\n    const query = beforeCaret.slice(linkStart + LINK_OPEN.length);\n    if (!query.includes(LINK_CLOSE) && !query.includes('\\n') && !query.includes('|')) {\n      return { end: caret, kind: LinkAndTagCompletionKind.Link, query, start: linkStart };\n    }\n  }\n\n  if (TAG_BEFORE_CARET_REG_EXP.test(beforeCaret)) {\n    // The query holds no #, so the last one is the trigger.\n    const start = beforeCaret.lastIndexOf(TAG_PREFIX);\n    return { end: caret, kind: LinkAndTagCompletionKind.Tag, query: beforeCaret.slice(start + TAG_PREFIX.length), start };\n  }\n\n  return null;\n}\n\n/**\n * Gets the tags of every note matching a query, as {@link LinkAndTagInputSuggest} and {@link TagListComponent}\n * suggest them.\n *\n * @param params - The parameters.\n * @returns The suggestions, best match first, then the most used.\n */\nexport function getVaultTagSuggestions(params: GetVaultTagSuggestionsParams): TagSuggestion[] {\n  const { app, query } = params;\n  const counts = new Map<string, number>();\n  for (const file of app.vault.getMarkdownFiles()) {\n    const cache = app.metadataCache.getFileCache(file);\n    for (const tag of (cache ? getAllTags(cache) : null) ?? []) {\n      const name = tag.slice(TAG_PREFIX.length);\n      counts.set(name, (counts.get(name) ?? 0) + 1);\n    }\n  }\n\n  const fuzzySearch = prepareFuzzySearch(query);\n  const results: SuggestionSearchResult<TagSuggestion>[] = [];\n  const sortedCounts = [...counts].sort(([tag1, count1], [tag2, count2]) => count2 - count1 || tag1.localeCompare(tag2));\n  for (const [tag, count] of sortedCounts) {\n    const match = fuzzySearch(tag);\n    if (match) {\n      results.push({ match, suggestion: { count, kind: LinkAndTagCompletionKind.Tag, tag } });\n    }\n  }\n  sortSearchResults(results);\n  return results.map((result) => result.suggestion);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,SAAS,cAAc;AACvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAQA,IAAK,2BAAL,kBAAKA,8BAAL;AAIL,EAAAA,0BAAA,UAAO;AAKP,EAAAA,0BAAA,SAAM;AATI,SAAAA;AAAA,GAAA;AAqHZ,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,aAAa;AACnB,MAAM,2BAA2B;AA8B1B,MAAM,+BAA+B,qBAA2C;AAAA;AAAA;AAAA;AAAA,EAIlE;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOZ,YAAY,QAAiD;AAElE,UAAM,OAAO,KAAK,OAAyB,OAAO,OAAO,CAAC;AAC1D,SAAK,UAAU,OAAO;AACtB,SAAK,qBAAqB,OAAO,sBAAsB;AACvD,SAAK,oBAAoB,OAAO,qBAAqB;AACrD,SAAK,aAAa,OAAO,cAAc;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOgB,WAAmB;AACjC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,iBAAiB,YAAkC,IAAuB;AAC/E,QAAI,WAAW,SAAS,mBAA+B;AACrD,SAAG,UAAU,EAAE,KAAK,oBAAoB,MAAM,WAAW,SAAS,CAAC;AACnE,UAAI,WAAW,aAAa,WAAW,KAAK,MAAM;AAChD,WAAG,UAAU,EAAE,KAAK,mBAAmB,MAAM,WAAW,KAAK,KAAK,CAAC;AAAA,MACrE;AACA;AAAA,IACF;AAEA,OAAG,SAAS,aAAa;AACzB,OAAG,UAAU,EAAE,KAAK,sBAAsB,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,GAAG,CAAC;AAClF,OAAG,UAAU,EAAE,KAAK,kBAAkB,MAAM,OAAO,WAAW,KAAK,EAAE,CAAC;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASgB,iBAAiB,YAAkC,QAA0C;AAC3G,UAAM,UAAU,KAAK,WAAW;AAChC,QAAI,SAAS;AACX,YAAM,QAAQ,KAAK,SAAS;AAC5B,UAAI,QAAQ,MAAM,MAAM,QAAQ,GAAG;AACnC,UAAI;AACJ,UAAI,WAAW,SAAS,mBAA+B;AACrD,oBAAY,GAAG,SAAS,GAAG,WAAW,QAAQ,GAAG,UAAU;AAC3D,YAAI,MAAM,WAAW,UAAU,GAAG;AAChC,kBAAQ,MAAM,MAAM,WAAW,MAAM;AAAA,QACvC;AAAA,MACF,OAAO;AACL,oBAAY,GAAG,UAAU,GAAG,WAAW,GAAG;AAAA,MAC5C;AAEA,WAAK,SAAS,MAAM,MAAM,GAAG,QAAQ,KAAK,IAAI,YAAY,KAAK;AAC/D,YAAM,QAAQ,QAAQ,QAAQ,UAAU;AACxC,WAAK,QAAQ,kBAAkB,OAAO,KAAK;AAC3C,WAAK,QAAQ,cAAc,IAAI,MAAM,SAAS,EAAE,SAAS,KAAK,CAAC,CAAC;AAAA,IAClE;AAEA,UAAM,iBAAiB,YAAY,MAAM;AACzC,SAAK,MAAM;AAAA,EACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOgB,SAAS,OAAqB;AAC5C,SAAK,QAAQ,QAAQ;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,mBAAmB,OAAiC;AAC5D,UAAM,cAAc,mBAAmB,KAAK;AAC5C,UAAM,UAAoD,CAAC;AAC3D,eAAW,QAAQ,KAAK,IAAI,MAAM,SAAS,GAAG;AAC5C,YAAM,WAAW,KAAK,IAAI,cAAc,eAAe,MAAM,KAAK,YAAY,IAAI;AAClF,YAAM,QAAQ,YAAY,QAAQ,KAAK,YAAY,KAAK,IAAI;AAC5D,UAAI,OAAO;AACT,gBAAQ,KAAK,EAAE,OAAO,YAAY,EAAE,MAAM,MAAM,mBAA+B,SAAS,EAAE,CAAC;AAAA,MAC7F;AAAA,IACF;AACA,sBAAkB,OAAO;AACzB,WAAO,QAAQ,IAAI,CAAC,WAAW,OAAO,UAAU;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,iBAAyC;AAC1D,UAAM,UAAU,KAAK,WAAW;AAChC,QAAI,SAAS,SAAS,mBAA+B;AACnD,aAAO,KAAK,mBAAmB,QAAQ,KAAK;AAAA,IAC9C;AACA,WAAO,SAAS,SAAS,kBAA+B,KAAK,kBAAkB,QAAQ,KAAK,IAAI,CAAC;AAAA,EACnG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,kBAAkB,OAAgC;AAC1D,WAAO,uBAAuB,EAAE,KAAK,KAAK,KAAK,MAAM,CAAC;AAAA,EACxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,aAAiD;AACzD,UAAM,QAAQ,KAAK,SAAS;AAC5B,UAAM,UAAU,+BAA+B,OAAO,KAAK,QAAQ,kBAAkB,MAAM,MAAM;AACjG,QAAI,SAAS,SAAS,qBAAiC,CAAC,KAAK,oBAAoB;AAC/E,aAAO;AAAA,IACT;AACA,WAAO,SAAS,SAAS,mBAAgC,CAAC,KAAK,oBAAoB,OAAO;AAAA,EAC5F;AACF;AAYO,SAAS,+BAA+B,MAAc,OAAmD;AAC9G,QAAM,cAAc,KAAK,MAAM,GAAG,KAAK;AACvC,QAAM,YAAY,YAAY,YAAY,SAAS;AACnD,MAAI,cAAc,IAAI;AACpB,UAAM,QAAQ,YAAY,MAAM,YAAY,UAAU,MAAM;AAC5D,QAAI,CAAC,MAAM,SAAS,UAAU,KAAK,CAAC,MAAM,SAAS,IAAI,KAAK,CAAC,MAAM,SAAS,GAAG,GAAG;AAChF,aAAO,EAAE,KAAK,OAAO,MAAM,mBAA+B,OAAO,OAAO,UAAU;AAAA,IACpF;AAAA,EACF;AAEA,MAAI,yBAAyB,KAAK,WAAW,GAAG;AAE9C,UAAM,QAAQ,YAAY,YAAY,UAAU;AAChD,WAAO,EAAE,KAAK,OAAO,MAAM,iBAA8B,OAAO,YAAY,MAAM,QAAQ,WAAW,MAAM,GAAG,MAAM;AAAA,EACtH;AAEA,SAAO;AACT;AASO,SAAS,uBAAuB,QAAuD;AAC5F,QAAM,EAAE,KAAK,MAAM,IAAI;AACvB,QAAM,SAAS,oBAAI,IAAoB;AACvC,aAAW,QAAQ,IAAI,MAAM,iBAAiB,GAAG;AAC/C,UAAM,QAAQ,IAAI,cAAc,aAAa,IAAI;AACjD,eAAW,QAAQ,QAAQ,WAAW,KAAK,IAAI,SAAS,CAAC,GAAG;AAC1D,YAAM,OAAO,IAAI,MAAM,WAAW,MAAM;AACxC,aAAO,IAAI,OAAO,OAAO,IAAI,IAAI,KAAK,KAAK,CAAC;AAAA,IAC9C;AAAA,EACF;AAEA,QAAM,cAAc,mBAAmB,KAAK;AAC5C,QAAM,UAAmD,CAAC;AAC1D,QAAM,eAAe,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,CAAC,MAAM,MAAM,GAAG,CAAC,MAAM,MAAM,MAAM,SAAS,UAAU,KAAK,cAAc,IAAI,CAAC;AACrH,aAAW,CAAC,KAAK,KAAK,KAAK,cAAc;AACvC,UAAM,QAAQ,YAAY,GAAG;AAC7B,QAAI,OAAO;AACT,cAAQ,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,MAAM,iBAA8B,IAAI,EAAE,CAAC;AAAA,IACxF;AAAA,EACF;AACA,oBAAkB,OAAO;AACzB,SAAO,QAAQ,IAAI,CAAC,WAAW,OAAO,UAAU;AAClD;","names":["LinkAndTagCompletionKind"]}

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

@@ -83,10 +83,23 @@ export interface ReplaceCodeBlockParams extends GetCodeBlockMarkdownInfoParams {
      * Provides a new code block.
      */
     readonly codeBlockProvider: ValueProvider<string, ContentArguments>;
+    /**
+     * A state passed to the next render of the code block, which gets it from {@link claimCodeBlockRenderHandoff}.
+     *
+     * @default `undefined`
+     */
+    readonly nextRenderState?: unknown;
     /**
      * The resource-lock component used to lock the note while it is being modified.
      */
     readonly resourceLockComponent: null | ResourceLockComponent;
+    /**
+     * Whether the next render of the code block may put the focus back where it is now inside {@link el}, through
+     * {@link claimCodeBlockRenderHandoff}.
+     *
+     * @default `false`
+     */
+    readonly shouldCarryFocusToNextRender?: boolean;
     /**
      * Whether to keep the gap when the new code block is empty.
      *
@@ -133,6 +146,11 @@ export declare function removeCodeBlock(params: RemoveCodeBlockParams): Promise<
 /**
  * Replaces the code block.
  *
+ * Obsidian renders the block again from its new source. To keep the focus or plugin state across that render, pass
+ * {@link ReplaceCodeBlockParams.shouldCarryFocusToNextRender} or {@link ReplaceCodeBlockParams.nextRenderState}, and
+ * call {@link claimCodeBlockRenderHandoff} from the processor. When the note is open in an editor, Obsidian applies
+ * the write as one change the user can undo.
+ *
  * @param params - The parameters for the function.
  */
 export declare function replaceCodeBlock(params: ReplaceCodeBlockParams): Promise<void>;

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

@@ -49,6 +49,10 @@ import { resolveValue } from "@mnaoumov/typescript-lib/value-provider";
 import { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
 import { MarkdownView } from "obsidian";
 import { createCodeBlockRegExp } from "./code-block-reg-exp.mjs";
+import {
+  captureCodeBlockFocus,
+  recordCodeBlockRenderHandoff
+} from "./code-block-render-handoff.mjs";
 import { getFileOrNull } from "./file-system.mjs";
 import {
   invokeWithFileSystemLock,
@@ -121,6 +125,9 @@ async function removeCodeBlock(params) {
 async function replaceCodeBlock(params) {
   const { app, codeBlockProvider, context } = params;
   params.abortSignal?.throwIfAborted();
+  const shouldRecordHandoff = params.shouldCarryFocusToNextRender === true || params.nextRenderState !== void 0;
+  const focus = params.shouldCarryFocusToNextRender ? captureCodeBlockFocus(params.el) : null;
+  let isHandoffRecorded = false;
   await process({
     app,
     async newContentProvider({ abortSignal, content }) {
@@ -150,6 +157,14 @@ async function replaceCodeBlock(params) {
       }
       const textBeforeCodeBlock = content.slice(0, markdownInfo.positionInNote.start.offset);
       const textAfterCodeBlock = content.slice(markdownInfo.positionInNote.end.offset);
+      if (shouldRecordHandoff && !isHandoffRecorded && newCodeBlock) {
+        isHandoffRecorded = recordCodeBlockRenderHandoff({
+          focus,
+          newCodeBlock,
+          sourcePath: context.sourcePath,
+          state: params.nextRenderState
+        });
+      }
       if (newCodeBlock || params.shouldKeepGapWhenEmpty) {
         return `${textBeforeCodeBlock}${newCodeBlock}${textAfterCodeBlock}`;
       }
@@ -344,4 +359,4 @@ export {
   removeCodeBlock,
   replaceCodeBlock
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/markdown-code-block-processor.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides utility functions for processing code blocks in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider';\nimport type {\n  App,\n  MarkdownPostProcessorContext,\n  MarkdownSectionInformation,\n  TFile\n} from 'obsidian';\n\nimport { abortSignalAny } from '@mnaoumov/typescript-lib/abort-controller';\nimport { requestAnimationFrameAsync } from '@mnaoumov/typescript-lib/async';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  getMandatoryNamedGroup,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport {\n  ensureLfEndings,\n  getLfNormalizedOffsetToOriginalOffsetMapper,\n  hasSingleOccurrence,\n  indent,\n  unindent\n} from '@mnaoumov/typescript-lib/string';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { resolveValue } from '@mnaoumov/typescript-lib/value-provider';\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { MarkdownView } from 'obsidian';\n\nimport type { CodeBlockMarkdownInformation } from './code-block-markdown-information.ts';\nimport type { ResourceLockComponent } from './resource-lock.ts';\nimport type { ContentArguments } from './vault.ts';\n\nimport { createCodeBlockRegExp } from './code-block-reg-exp.ts';\nimport { getFileOrNull } from './file-system.ts';\nimport {\n  invokeWithFileSystemLock,\n  process,\n  saveNote\n} from './vault.ts';\n\n/**\n * Options for {@link getCodeBlockMarkdownInfo}.\n */\nexport interface GetCodeBlockMarkdownInfoParams {\n  /**\n   * An Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * A {@link MarkdownPostProcessorContext} object.\n   */\n  readonly context: MarkdownPostProcessorContext;\n\n  /**\n   * A {@link HTMLElement} representing the code block.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * A source of the code block.\n   */\n  readonly source: string;\n}\n\n/**\n * Options for {@link insertAfterCodeBlock} / {@link insertBeforeCodeBlock}.\n */\nexport interface InsertCodeBlockParams extends GetCodeBlockMarkdownInfoParams {\n  /**\n   * A number of lines to offset the insertion by.\n   *\n   * @default `0`\n   */\n  readonly lineOffset?: number;\n\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Whether to preserve the line prefix of the code block.\n   *\n   * @default `false`\n   */\n  readonly shouldPreserveLinePrefix?: boolean;\n\n  /**\n   * A text to insert after the code block.\n   */\n  readonly text: string;\n}\n\n/**\n * Options for {@link removeCodeBlock}.\n */\nexport interface RemoveCodeBlockParams extends GetCodeBlockMarkdownInfoParams {\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Whether to keep the gap after removing the code block.\n   *\n   * @default `false`\n   */\n  readonly shouldKeepGap?: boolean;\n}\n\n/**\n * Options for {@link replaceCodeBlock}.\n */\nexport interface ReplaceCodeBlockParams extends GetCodeBlockMarkdownInfoParams {\n  /**\n   * An abort signal to control the execution of the function.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Provides a new code block.\n   */\n  readonly codeBlockProvider: ValueProvider<string, ContentArguments>;\n\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Whether to keep the gap when the new code block is empty.\n   *\n   * @default `false`\n   */\n  readonly shouldKeepGapWhenEmpty?: boolean;\n\n  /**\n   * Whether to preserve the line prefix of the code block.\n   *\n   * @default `false`\n   */\n  readonly shouldPreserveLinePrefix?: boolean;\n}\n\ninterface CreateMarkdownInfoFromMatchParams {\n  readonly approximateSectionInfo: MarkdownSectionInformation;\n  readonly linesBeforeSectionCount: number;\n  readonly match: RegExpMatchArray;\n  readonly noteContent: string;\n  readonly potentialCodeBlockText: string;\n  readonly sourceLinesCount: number;\n  readonly textLineOffsets: ReadonlyMap<number, number>;\n}\n\ninterface FindCodeBlockMarkdownInfoParams {\n  /**\n   * The element the code block was rendered into.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The note text to locate the code block in.\n   */\n  readonly noteContent: string;\n\n  /**\n   * The source of the code block.\n   */\n  readonly source: string;\n}\n\ninterface InsertTextParams {\n  /**\n   * The content to insert the text into.\n   */\n  readonly content: string;\n\n  /**\n   * The line index to insert the text at.\n   */\n  readonly insertLineIndex: number;\n\n  /**\n   * Whether to preserve the line prefix of the line at the insertion point.\n   *\n   * @default `false`\n   */\n  readonly shouldPreserveLinePrefix?: boolean;\n\n  /**\n   * The text to insert.\n   */\n  readonly text: string;\n}\n\ninterface IsSuitableCodeBlockParams {\n  /**\n   * Whether the code block is inside a callout.\n   */\n  readonly isInCallout: boolean;\n\n  /**\n   * The language the code block is expected to have.\n   */\n  readonly language: string;\n\n  /**\n   * The regular expression match of the code block candidate.\n   */\n  readonly match: RegExpMatchArray;\n\n  /**\n   * The LF-normalized source of the code block.\n   */\n  readonly sourceLf: string;\n}\n\n/**\n * Gets the information about a code block in a Markdown section.\n *\n * This is a pure read, safe to call while a code block renders. It locates the block in the text the\n * user sees: the view data of an open markdown view of the source note when there is one, because\n * an unsaved edit there is what the block was rendered from, and the file's content otherwise. It\n * never saves the note.\n *\n * @param params - The parameters for the function.\n * @returns The information about the code block in the Markdown section.\n */\nexport async function getCodeBlockMarkdownInfo(params: GetCodeBlockMarkdownInfoParams): Promise<CodeBlockMarkdownInformation | null> {\n  const { app, context, el, source } = params;\n\n  const sourceFile = getFileOrNull({ app, pathOrFile: context.sourcePath });\n  assertNonNullable(sourceFile, `Source file ${context.sourcePath} not found.`);\n\n  await requestAnimationFrameAsync();\n\n  const noteContent = getOpenMarkdownViewData(app, sourceFile) ?? await app.vault.read(sourceFile);\n  return findCodeBlockMarkdownInfo({ el, noteContent, source });\n}\n\n/**\n * Inserts text after the code block.\n *\n * @param params - The parameters for the function.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares InsertCodeBlockParams with insertBeforeCodeBlock.\nexport async function insertAfterCodeBlock(params: InsertCodeBlockParams): Promise<void> {\n  const { app, context, lineOffset = 0, text } = params;\n\n  await process({\n    app,\n    async newContentProvider({ content }) {\n      const markdownInfo = await getCodeBlockMarkdownInfoAfterSave(params);\n      assertNonNullable(markdownInfo, 'Could not uniquely identify the code block.');\n\n      if (content !== markdownInfo.noteContent) {\n        return null;\n      }\n\n      const insertLineIndex = markdownInfo.positionInNote.end.line + lineOffset + 1;\n      return insertText(normalizeOptionalProperties<InsertTextParams>({\n        content,\n        insertLineIndex,\n        shouldPreserveLinePrefix: params.shouldPreserveLinePrefix,\n        text\n      }));\n    },\n    pathOrFile: context.sourcePath,\n    pluginNoticeComponent: null,\n    resourceLockComponent: params.resourceLockComponent\n  });\n}\n\n/**\n * Inserts text before the code block.\n *\n * @param params - The parameters for the function.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares InsertCodeBlockParams with insertAfterCodeBlock.\nexport async function insertBeforeCodeBlock(params: InsertCodeBlockParams): Promise<void> {\n  const { app, context, lineOffset = 0, text } = params;\n\n  await process({\n    app,\n    async newContentProvider({ content }) {\n      const markdownInfo = await getCodeBlockMarkdownInfoAfterSave(params);\n      if (!markdownInfo) {\n        throw new Error('Could not uniquely identify the code block.');\n      }\n\n      if (content !== markdownInfo.noteContent) {\n        return null;\n      }\n\n      const insertLineIndex = markdownInfo.positionInNote.start.line - lineOffset;\n      return insertText(normalizeOptionalProperties<InsertTextParams>({\n        content,\n        insertLineIndex,\n        shouldPreserveLinePrefix: params.shouldPreserveLinePrefix,\n        text\n      }));\n    },\n    pathOrFile: context.sourcePath,\n    pluginNoticeComponent: null,\n    resourceLockComponent: params.resourceLockComponent\n  });\n}\n\n/**\n * Removes the code block.\n *\n * @param params - The parameters for the function.\n */\nexport async function removeCodeBlock(params: RemoveCodeBlockParams): Promise<void> {\n  await replaceCodeBlock({\n    ...params,\n    codeBlockProvider: '',\n    shouldKeepGapWhenEmpty: params.shouldKeepGap ?? false\n  });\n}\n\n/**\n * Replaces the code block.\n *\n * @param params - The parameters for the function.\n */\nexport async function replaceCodeBlock(params: ReplaceCodeBlockParams): Promise<void> {\n  const { app, codeBlockProvider, context } = params;\n  params.abortSignal?.throwIfAborted();\n\n  await process({\n    app,\n    async newContentProvider({ abortSignal, content }) {\n      abortSignal = abortSignalAny(abortSignal, params.abortSignal);\n      abortSignal.throwIfAborted();\n      const markdownInfo = await getCodeBlockMarkdownInfoAfterSave(params);\n      if (!markdownInfo) {\n        throw new Error('Could not uniquely identify the code block.');\n      }\n\n      if (content !== markdownInfo.noteContent) {\n        return null;\n      }\n\n      let oldCodeBlock = content.slice(markdownInfo.positionInNote.start.offset, markdownInfo.positionInNote.end.offset);\n      if (params.shouldPreserveLinePrefix) {\n        oldCodeBlock = unindent({\n          prefix: markdownInfo.linePrefix,\n          text: oldCodeBlock\n        });\n      }\n\n      let newCodeBlock = await resolveValue(codeBlockProvider, { abortSignal, content: oldCodeBlock });\n      abortSignal.throwIfAborted();\n      if ((newCodeBlock || params.shouldKeepGapWhenEmpty) && params.shouldPreserveLinePrefix) {\n        newCodeBlock = indent({\n          prefix: markdownInfo.linePrefix,\n          text: newCodeBlock\n        });\n      }\n\n      const textBeforeCodeBlock = content.slice(0, markdownInfo.positionInNote.start.offset);\n      const textAfterCodeBlock = content.slice(markdownInfo.positionInNote.end.offset);\n\n      if (newCodeBlock || params.shouldKeepGapWhenEmpty) {\n        return `${textBeforeCodeBlock}${newCodeBlock}${textAfterCodeBlock}`;\n      }\n\n      if (!textBeforeCodeBlock && !textAfterCodeBlock) {\n        return '';\n      }\n\n      return textBeforeCodeBlock ? `${textBeforeCodeBlock.slice(0, -1)}${textAfterCodeBlock}` : `${textBeforeCodeBlock}${textAfterCodeBlock.slice(1)}`;\n    },\n    pathOrFile: context.sourcePath,\n    pluginNoticeComponent: null,\n    resourceLockComponent: params.resourceLockComponent\n  });\n}\n\nfunction createMarkdownInfoFromMatch(params: CreateMarkdownInfoFromMatchParams): CodeBlockMarkdownInformation {\n  const {\n    approximateSectionInfo,\n    linesBeforeSectionCount,\n    match,\n    noteContent,\n    potentialCodeBlockText,\n    sourceLinesCount,\n    textLineOffsets\n  } = params;\n\n  const linePrefix = getMandatoryNamedGroup(match, 'LinePrefix');\n  const codeBlockStartDelimiter = getMandatoryNamedGroup(match, 'CodeBlockStartDelimiter');\n  const codeBlockEndDelimiter = getMandatoryNamedGroup(match, 'CodeBlockEndDelimiter');\n  const codeBlockArgumentsString = getOptionalNamedGroup(match, 'CodeBlockArgs') ?? '';\n  const language = getMandatoryNamedGroup(match, 'CodeBlockLanguage');\n\n  const previousText = potentialCodeBlockText.slice(0, match.index);\n  const previousTextLinesCount = previousText.split('\\n').length - 1;\n\n  const startLine = linesBeforeSectionCount + previousTextLinesCount;\n  const endLine = startLine + sourceLinesCount + 1;\n\n  return {\n    $arguments: codeBlockArgumentsString.split(/\\s+/).filter(Boolean),\n    endDelimiter: codeBlockEndDelimiter,\n    language,\n    linePrefix,\n    noteContent,\n    positionInNote: {\n      end: {\n        col: (textLineOffsets.get(endLine + 1) ?? 0) - (textLineOffsets.get(endLine) ?? 0) - 1,\n        line: endLine,\n        offset: (textLineOffsets.get(endLine + 1) ?? 0) - 1\n      },\n      start: {\n        col: 0,\n        line: startLine,\n        offset: textLineOffsets.get(startLine) ?? 0\n      }\n    },\n    rawArgumentsString: codeBlockArgumentsString,\n    sectionInfo: {\n      lineEnd: previousTextLinesCount + sourceLinesCount + 1,\n      lineStart: previousTextLinesCount,\n      text: approximateSectionInfo.text\n    },\n    startDelimiter: codeBlockStartDelimiter\n  };\n}\n\nfunction findCodeBlockMarkdownInfo(params: FindCodeBlockMarkdownInfoParams): CodeBlockMarkdownInformation | null {\n  const { el, noteContent, source } = params;\n  const noteContentLf = ensureLfEndings(noteContent);\n\n  const approximateSectionInfo: MarkdownSectionInformation = {\n    lineEnd: noteContentLf.split('\\n').length - 1,\n    lineStart: 0,\n    text: noteContentLf\n  };\n\n  approximateSectionInfo.text = ensureLfEndings(approximateSectionInfo.text);\n\n  if (\n    !hasSingleOccurrence({\n      $string: noteContentLf,\n      searchValue: approximateSectionInfo.text\n    })\n  ) {\n    return null;\n  }\n\n  const sourceLf = ensureLfEndings(source);\n\n  const sectionOffset = noteContentLf.indexOf(approximateSectionInfo.text);\n  const linesBeforeSectionCount = noteContentLf.slice(0, sectionOffset).split('\\n').length - 1;\n\n  const isInCallout = !!el.parentElement?.classList.contains('callout-content');\n\n  const language = getLanguageFromElement(el);\n  const sourceLines = sourceLf.split('\\n');\n\n  const textLines = approximateSectionInfo.text.split('\\n');\n  const textLineOffsets = new Map<number, number>([[linesBeforeSectionCount, sectionOffset]]);\n\n  let lastTextLineOffset = sectionOffset;\n  for (const [index, textLine_] of textLines.entries()) {\n    const textLine = textLine_;\n    const lineOffset = lastTextLineOffset + textLine.length + 1;\n    textLineOffsets.set(linesBeforeSectionCount + index + 1, lineOffset);\n    lastTextLineOffset = lineOffset;\n  }\n\n  const potentialCodeBlockTextLines = textLines.map((line, index) => approximateSectionInfo.lineStart <= index && index <= approximateSectionInfo.lineEnd ? line : '');\n  const potentialCodeBlockText = potentialCodeBlockTextLines.join('\\n');\n\n  const REG_EXP = createCodeBlockRegExp();\n\n  let markdownInfo: CodeBlockMarkdownInformation | null = null;\n\n  for (const match of potentialCodeBlockText.matchAll(REG_EXP)) {\n    if (!isSuitableCodeBlock({ isInCallout, language, match, sourceLf })) {\n      continue;\n    }\n\n    if (markdownInfo) {\n      // A second identical block: the element cannot say which one it was rendered from.\n      return null;\n    }\n\n    markdownInfo = createMarkdownInfoFromMatch({\n      approximateSectionInfo,\n      linesBeforeSectionCount,\n      match,\n      noteContent,\n      potentialCodeBlockText,\n      sourceLinesCount: sourceLines.length,\n      textLineOffsets\n    });\n  }\n\n  if (!markdownInfo || (noteContentLf === noteContent)) {\n    return markdownInfo;\n  }\n\n  const lfOffsetMapper = getLfNormalizedOffsetToOriginalOffsetMapper(noteContent);\n  markdownInfo.positionInNote.start.offset = lfOffsetMapper(markdownInfo.positionInNote.start.offset);\n  markdownInfo.positionInNote.end.offset = lfOffsetMapper(markdownInfo.positionInNote.end.offset);\n  return markdownInfo;\n}\n\n/**\n * The flushing counterpart of {@link getCodeBlockMarkdownInfo}, for the write helpers only.\n *\n * It saves the note first and reads the file, because a write helper compares the returned\n * `noteContent` against the file content {@link process} hands it: text taken from a dirty editor\n * would never match, and the provider would ask for a retry forever. A write is about to happen\n * anyway, so the save is not a write on an automatic trigger.\n *\n * @param params - The parameters for the function.\n * @returns The information about the code block, located in the saved file content.\n */\nasync function getCodeBlockMarkdownInfoAfterSave(params: GetCodeBlockMarkdownInfoParams): Promise<CodeBlockMarkdownInformation | null> {\n  const { app, context, el, source } = params;\n\n  const sourceFile = getFileOrNull({ app, pathOrFile: context.sourcePath });\n  assertNonNullable(sourceFile, `Source file ${context.sourcePath} not found.`);\n\n  await requestAnimationFrameAsync();\n  await saveNote(app, sourceFile);\n\n  let markdownInfo: CodeBlockMarkdownInformation | null = null;\n\n  await invokeWithFileSystemLock({\n    $function(noteContent) {\n      markdownInfo = findCodeBlockMarkdownInfo({ el, noteContent, source });\n    },\n    app,\n    pathOrFile: sourceFile\n  });\n\n  return markdownInfo;\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 getOpenMarkdownViewData(app: App, file: TFile): null | string {\n  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n    if (leaf.view instanceof MarkdownView && leaf.view.file?.path === file.path) {\n      return leaf.view.getViewData();\n    }\n  }\n\n  return null;\n}\n\nfunction insertText(params: InsertTextParams): string {\n  const { content, shouldPreserveLinePrefix = false, text } = params;\n  let { insertLineIndex } = params;\n\n  const lines = content.split('\\n');\n  const newLines = [...lines];\n  const textLines = text.split('\\n');\n\n  if (insertLineIndex < 0) {\n    insertLineIndex = 0;\n  }\n  if (insertLineIndex > lines.length) {\n    insertLineIndex = lines.length;\n  }\n\n  const PREFIX_LINE_REG_EXP = /^ {0,3}(?:> {1,3})*/g;\n  const match = (lines[insertLineIndex] ?? '').match(PREFIX_LINE_REG_EXP);\n  const linePrefix = match?.[0] ?? '';\n  newLines.splice(\n    insertLineIndex,\n    0,\n    ...(shouldPreserveLinePrefix\n      ? textLines.map((line) =>\n        indent({\n          prefix: linePrefix,\n          text: line\n        })\n      )\n      : textLines)\n  );\n  return newLines.join('\\n');\n}\n\nfunction isSuitableCodeBlock(params: IsSuitableCodeBlockParams): boolean {\n  const { isInCallout, language, match, sourceLf } = params;\n\n  const codeBlockLanguage = getMandatoryNamedGroup(match, 'CodeBlockLanguage');\n  if (codeBlockLanguage !== language) {\n    return false;\n  }\n\n  const linePrefix = getMandatoryNamedGroup(match, 'LinePrefix');\n\n  if (isInCallout && !linePrefix.includes('> ')) {\n    return false;\n  }\n\n  const codeBlockContent = getOptionalNamedGroup(match, 'CodeBlockContent') ?? '';\n  const cleanCodeBlockContent = codeBlockContent.split('\\n').map((line) => line.slice(linePrefix.length)).join('\\n');\n\n  return cleanCodeBlockContent === sourceLf;\n}\n\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/markdown-code-block-processor.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides utility functions for processing code blocks in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type { ValueProvider } from '@mnaoumov/typescript-lib/value-provider';\nimport type {\n  App,\n  MarkdownPostProcessorContext,\n  MarkdownSectionInformation,\n  TFile\n} from 'obsidian';\n\nimport { abortSignalAny } from '@mnaoumov/typescript-lib/abort-controller';\nimport { requestAnimationFrameAsync } from '@mnaoumov/typescript-lib/async';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  getMandatoryNamedGroup,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport {\n  ensureLfEndings,\n  getLfNormalizedOffsetToOriginalOffsetMapper,\n  hasSingleOccurrence,\n  indent,\n  unindent\n} from '@mnaoumov/typescript-lib/string';\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { resolveValue } from '@mnaoumov/typescript-lib/value-provider';\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { MarkdownView } from 'obsidian';\n\nimport type { CodeBlockMarkdownInformation } from './code-block-markdown-information.ts';\nimport type { CodeBlockFocusSnapshot } from './code-block-render-handoff.ts';\nimport type { ResourceLockComponent } from './resource-lock.ts';\nimport type { ContentArguments } from './vault.ts';\n\nimport { createCodeBlockRegExp } from './code-block-reg-exp.ts';\nimport {\n  captureCodeBlockFocus,\n  recordCodeBlockRenderHandoff\n} from './code-block-render-handoff.ts';\nimport { getFileOrNull } from './file-system.ts';\nimport {\n  invokeWithFileSystemLock,\n  process,\n  saveNote\n} from './vault.ts';\n\n/**\n * Options for {@link getCodeBlockMarkdownInfo}.\n */\nexport interface GetCodeBlockMarkdownInfoParams {\n  /**\n   * An Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * A {@link MarkdownPostProcessorContext} object.\n   */\n  readonly context: MarkdownPostProcessorContext;\n\n  /**\n   * A {@link HTMLElement} representing the code block.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * A source of the code block.\n   */\n  readonly source: string;\n}\n\n/**\n * Options for {@link insertAfterCodeBlock} / {@link insertBeforeCodeBlock}.\n */\nexport interface InsertCodeBlockParams extends GetCodeBlockMarkdownInfoParams {\n  /**\n   * A number of lines to offset the insertion by.\n   *\n   * @default `0`\n   */\n  readonly lineOffset?: number;\n\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Whether to preserve the line prefix of the code block.\n   *\n   * @default `false`\n   */\n  readonly shouldPreserveLinePrefix?: boolean;\n\n  /**\n   * A text to insert after the code block.\n   */\n  readonly text: string;\n}\n\n/**\n * Options for {@link removeCodeBlock}.\n */\nexport interface RemoveCodeBlockParams extends GetCodeBlockMarkdownInfoParams {\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Whether to keep the gap after removing the code block.\n   *\n   * @default `false`\n   */\n  readonly shouldKeepGap?: boolean;\n}\n\n/**\n * Options for {@link replaceCodeBlock}.\n */\nexport interface ReplaceCodeBlockParams extends GetCodeBlockMarkdownInfoParams {\n  /**\n   * An abort signal to control the execution of the function.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * Provides a new code block.\n   */\n  readonly codeBlockProvider: ValueProvider<string, ContentArguments>;\n\n  /**\n   * A state passed to the next render of the code block, which gets it from {@link claimCodeBlockRenderHandoff}.\n   *\n   * @default `undefined`\n   */\n  readonly nextRenderState?: unknown;\n\n  /**\n   * The resource-lock component used to lock the note while it is being modified.\n   */\n  readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Whether the next render of the code block may put the focus back where it is now inside {@link el}, through\n   * {@link claimCodeBlockRenderHandoff}.\n   *\n   * @default `false`\n   */\n  readonly shouldCarryFocusToNextRender?: boolean;\n\n  /**\n   * Whether to keep the gap when the new code block is empty.\n   *\n   * @default `false`\n   */\n  readonly shouldKeepGapWhenEmpty?: boolean;\n\n  /**\n   * Whether to preserve the line prefix of the code block.\n   *\n   * @default `false`\n   */\n  readonly shouldPreserveLinePrefix?: boolean;\n}\n\ninterface CreateMarkdownInfoFromMatchParams {\n  readonly approximateSectionInfo: MarkdownSectionInformation;\n  readonly linesBeforeSectionCount: number;\n  readonly match: RegExpMatchArray;\n  readonly noteContent: string;\n  readonly potentialCodeBlockText: string;\n  readonly sourceLinesCount: number;\n  readonly textLineOffsets: ReadonlyMap<number, number>;\n}\n\ninterface FindCodeBlockMarkdownInfoParams {\n  /**\n   * The element the code block was rendered into.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The note text to locate the code block in.\n   */\n  readonly noteContent: string;\n\n  /**\n   * The source of the code block.\n   */\n  readonly source: string;\n}\n\ninterface InsertTextParams {\n  /**\n   * The content to insert the text into.\n   */\n  readonly content: string;\n\n  /**\n   * The line index to insert the text at.\n   */\n  readonly insertLineIndex: number;\n\n  /**\n   * Whether to preserve the line prefix of the line at the insertion point.\n   *\n   * @default `false`\n   */\n  readonly shouldPreserveLinePrefix?: boolean;\n\n  /**\n   * The text to insert.\n   */\n  readonly text: string;\n}\n\ninterface IsSuitableCodeBlockParams {\n  /**\n   * Whether the code block is inside a callout.\n   */\n  readonly isInCallout: boolean;\n\n  /**\n   * The language the code block is expected to have.\n   */\n  readonly language: string;\n\n  /**\n   * The regular expression match of the code block candidate.\n   */\n  readonly match: RegExpMatchArray;\n\n  /**\n   * The LF-normalized source of the code block.\n   */\n  readonly sourceLf: string;\n}\n\n/**\n * Gets the information about a code block in a Markdown section.\n *\n * This is a pure read, safe to call while a code block renders. It locates the block in the text the\n * user sees: the view data of an open markdown view of the source note when there is one, because\n * an unsaved edit there is what the block was rendered from, and the file's content otherwise. It\n * never saves the note.\n *\n * @param params - The parameters for the function.\n * @returns The information about the code block in the Markdown section.\n */\nexport async function getCodeBlockMarkdownInfo(params: GetCodeBlockMarkdownInfoParams): Promise<CodeBlockMarkdownInformation | null> {\n  const { app, context, el, source } = params;\n\n  const sourceFile = getFileOrNull({ app, pathOrFile: context.sourcePath });\n  assertNonNullable(sourceFile, `Source file ${context.sourcePath} not found.`);\n\n  await requestAnimationFrameAsync();\n\n  const noteContent = getOpenMarkdownViewData(app, sourceFile) ?? await app.vault.read(sourceFile);\n  return findCodeBlockMarkdownInfo({ el, noteContent, source });\n}\n\n/**\n * Inserts text after the code block.\n *\n * @param params - The parameters for the function.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares InsertCodeBlockParams with insertBeforeCodeBlock.\nexport async function insertAfterCodeBlock(params: InsertCodeBlockParams): Promise<void> {\n  const { app, context, lineOffset = 0, text } = params;\n\n  await process({\n    app,\n    async newContentProvider({ content }) {\n      const markdownInfo = await getCodeBlockMarkdownInfoAfterSave(params);\n      assertNonNullable(markdownInfo, 'Could not uniquely identify the code block.');\n\n      if (content !== markdownInfo.noteContent) {\n        return null;\n      }\n\n      const insertLineIndex = markdownInfo.positionInNote.end.line + lineOffset + 1;\n      return insertText(normalizeOptionalProperties<InsertTextParams>({\n        content,\n        insertLineIndex,\n        shouldPreserveLinePrefix: params.shouldPreserveLinePrefix,\n        text\n      }));\n    },\n    pathOrFile: context.sourcePath,\n    pluginNoticeComponent: null,\n    resourceLockComponent: params.resourceLockComponent\n  });\n}\n\n/**\n * Inserts text before the code block.\n *\n * @param params - The parameters for the function.\n */\n// eslint-disable-next-line typescript-dev-toolkit/params-options-name-match -- Intentionally shares InsertCodeBlockParams with insertAfterCodeBlock.\nexport async function insertBeforeCodeBlock(params: InsertCodeBlockParams): Promise<void> {\n  const { app, context, lineOffset = 0, text } = params;\n\n  await process({\n    app,\n    async newContentProvider({ content }) {\n      const markdownInfo = await getCodeBlockMarkdownInfoAfterSave(params);\n      if (!markdownInfo) {\n        throw new Error('Could not uniquely identify the code block.');\n      }\n\n      if (content !== markdownInfo.noteContent) {\n        return null;\n      }\n\n      const insertLineIndex = markdownInfo.positionInNote.start.line - lineOffset;\n      return insertText(normalizeOptionalProperties<InsertTextParams>({\n        content,\n        insertLineIndex,\n        shouldPreserveLinePrefix: params.shouldPreserveLinePrefix,\n        text\n      }));\n    },\n    pathOrFile: context.sourcePath,\n    pluginNoticeComponent: null,\n    resourceLockComponent: params.resourceLockComponent\n  });\n}\n\n/**\n * Removes the code block.\n *\n * @param params - The parameters for the function.\n */\nexport async function removeCodeBlock(params: RemoveCodeBlockParams): Promise<void> {\n  await replaceCodeBlock({\n    ...params,\n    codeBlockProvider: '',\n    shouldKeepGapWhenEmpty: params.shouldKeepGap ?? false\n  });\n}\n\n/**\n * Replaces the code block.\n *\n * Obsidian renders the block again from its new source. To keep the focus or plugin state across that render, pass\n * {@link ReplaceCodeBlockParams.shouldCarryFocusToNextRender} or {@link ReplaceCodeBlockParams.nextRenderState}, and\n * call {@link claimCodeBlockRenderHandoff} from the processor. When the note is open in an editor, Obsidian applies\n * the write as one change the user can undo.\n *\n * @param params - The parameters for the function.\n */\nexport async function replaceCodeBlock(params: ReplaceCodeBlockParams): Promise<void> {\n  const { app, codeBlockProvider, context } = params;\n  params.abortSignal?.throwIfAborted();\n  const shouldRecordHandoff = params.shouldCarryFocusToNextRender === true || params.nextRenderState !== undefined;\n  const focus: CodeBlockFocusSnapshot | null = params.shouldCarryFocusToNextRender ? captureCodeBlockFocus(params.el) : null;\n  let isHandoffRecorded = false;\n\n  await process({\n    app,\n    async newContentProvider({ abortSignal, content }) {\n      abortSignal = abortSignalAny(abortSignal, params.abortSignal);\n      abortSignal.throwIfAborted();\n      const markdownInfo = await getCodeBlockMarkdownInfoAfterSave(params);\n      if (!markdownInfo) {\n        throw new Error('Could not uniquely identify the code block.');\n      }\n\n      if (content !== markdownInfo.noteContent) {\n        return null;\n      }\n\n      let oldCodeBlock = content.slice(markdownInfo.positionInNote.start.offset, markdownInfo.positionInNote.end.offset);\n      if (params.shouldPreserveLinePrefix) {\n        oldCodeBlock = unindent({\n          prefix: markdownInfo.linePrefix,\n          text: oldCodeBlock\n        });\n      }\n\n      let newCodeBlock = await resolveValue(codeBlockProvider, { abortSignal, content: oldCodeBlock });\n      abortSignal.throwIfAborted();\n      if ((newCodeBlock || params.shouldKeepGapWhenEmpty) && params.shouldPreserveLinePrefix) {\n        newCodeBlock = indent({\n          prefix: markdownInfo.linePrefix,\n          text: newCodeBlock\n        });\n      }\n\n      const textBeforeCodeBlock = content.slice(0, markdownInfo.positionInNote.start.offset);\n      const textAfterCodeBlock = content.slice(markdownInfo.positionInNote.end.offset);\n\n      if (shouldRecordHandoff && !isHandoffRecorded && newCodeBlock) {\n        // Recorded before the write, because an open editor can render the new source before the write settles.\n        isHandoffRecorded = recordCodeBlockRenderHandoff({\n          focus,\n          newCodeBlock,\n          sourcePath: context.sourcePath,\n          state: params.nextRenderState\n        });\n      }\n\n      if (newCodeBlock || params.shouldKeepGapWhenEmpty) {\n        return `${textBeforeCodeBlock}${newCodeBlock}${textAfterCodeBlock}`;\n      }\n\n      if (!textBeforeCodeBlock && !textAfterCodeBlock) {\n        return '';\n      }\n\n      return textBeforeCodeBlock ? `${textBeforeCodeBlock.slice(0, -1)}${textAfterCodeBlock}` : `${textBeforeCodeBlock}${textAfterCodeBlock.slice(1)}`;\n    },\n    pathOrFile: context.sourcePath,\n    pluginNoticeComponent: null,\n    resourceLockComponent: params.resourceLockComponent\n  });\n}\n\nfunction createMarkdownInfoFromMatch(params: CreateMarkdownInfoFromMatchParams): CodeBlockMarkdownInformation {\n  const {\n    approximateSectionInfo,\n    linesBeforeSectionCount,\n    match,\n    noteContent,\n    potentialCodeBlockText,\n    sourceLinesCount,\n    textLineOffsets\n  } = params;\n\n  const linePrefix = getMandatoryNamedGroup(match, 'LinePrefix');\n  const codeBlockStartDelimiter = getMandatoryNamedGroup(match, 'CodeBlockStartDelimiter');\n  const codeBlockEndDelimiter = getMandatoryNamedGroup(match, 'CodeBlockEndDelimiter');\n  const codeBlockArgumentsString = getOptionalNamedGroup(match, 'CodeBlockArgs') ?? '';\n  const language = getMandatoryNamedGroup(match, 'CodeBlockLanguage');\n\n  const previousText = potentialCodeBlockText.slice(0, match.index);\n  const previousTextLinesCount = previousText.split('\\n').length - 1;\n\n  const startLine = linesBeforeSectionCount + previousTextLinesCount;\n  const endLine = startLine + sourceLinesCount + 1;\n\n  return {\n    $arguments: codeBlockArgumentsString.split(/\\s+/).filter(Boolean),\n    endDelimiter: codeBlockEndDelimiter,\n    language,\n    linePrefix,\n    noteContent,\n    positionInNote: {\n      end: {\n        col: (textLineOffsets.get(endLine + 1) ?? 0) - (textLineOffsets.get(endLine) ?? 0) - 1,\n        line: endLine,\n        offset: (textLineOffsets.get(endLine + 1) ?? 0) - 1\n      },\n      start: {\n        col: 0,\n        line: startLine,\n        offset: textLineOffsets.get(startLine) ?? 0\n      }\n    },\n    rawArgumentsString: codeBlockArgumentsString,\n    sectionInfo: {\n      lineEnd: previousTextLinesCount + sourceLinesCount + 1,\n      lineStart: previousTextLinesCount,\n      text: approximateSectionInfo.text\n    },\n    startDelimiter: codeBlockStartDelimiter\n  };\n}\n\nfunction findCodeBlockMarkdownInfo(params: FindCodeBlockMarkdownInfoParams): CodeBlockMarkdownInformation | null {\n  const { el, noteContent, source } = params;\n  const noteContentLf = ensureLfEndings(noteContent);\n\n  const approximateSectionInfo: MarkdownSectionInformation = {\n    lineEnd: noteContentLf.split('\\n').length - 1,\n    lineStart: 0,\n    text: noteContentLf\n  };\n\n  approximateSectionInfo.text = ensureLfEndings(approximateSectionInfo.text);\n\n  if (\n    !hasSingleOccurrence({\n      $string: noteContentLf,\n      searchValue: approximateSectionInfo.text\n    })\n  ) {\n    return null;\n  }\n\n  const sourceLf = ensureLfEndings(source);\n\n  const sectionOffset = noteContentLf.indexOf(approximateSectionInfo.text);\n  const linesBeforeSectionCount = noteContentLf.slice(0, sectionOffset).split('\\n').length - 1;\n\n  const isInCallout = !!el.parentElement?.classList.contains('callout-content');\n\n  const language = getLanguageFromElement(el);\n  const sourceLines = sourceLf.split('\\n');\n\n  const textLines = approximateSectionInfo.text.split('\\n');\n  const textLineOffsets = new Map<number, number>([[linesBeforeSectionCount, sectionOffset]]);\n\n  let lastTextLineOffset = sectionOffset;\n  for (const [index, textLine_] of textLines.entries()) {\n    const textLine = textLine_;\n    const lineOffset = lastTextLineOffset + textLine.length + 1;\n    textLineOffsets.set(linesBeforeSectionCount + index + 1, lineOffset);\n    lastTextLineOffset = lineOffset;\n  }\n\n  const potentialCodeBlockTextLines = textLines.map((line, index) => approximateSectionInfo.lineStart <= index && index <= approximateSectionInfo.lineEnd ? line : '');\n  const potentialCodeBlockText = potentialCodeBlockTextLines.join('\\n');\n\n  const REG_EXP = createCodeBlockRegExp();\n\n  let markdownInfo: CodeBlockMarkdownInformation | null = null;\n\n  for (const match of potentialCodeBlockText.matchAll(REG_EXP)) {\n    if (!isSuitableCodeBlock({ isInCallout, language, match, sourceLf })) {\n      continue;\n    }\n\n    if (markdownInfo) {\n      // A second identical block: the element cannot say which one it was rendered from.\n      return null;\n    }\n\n    markdownInfo = createMarkdownInfoFromMatch({\n      approximateSectionInfo,\n      linesBeforeSectionCount,\n      match,\n      noteContent,\n      potentialCodeBlockText,\n      sourceLinesCount: sourceLines.length,\n      textLineOffsets\n    });\n  }\n\n  if (!markdownInfo || (noteContentLf === noteContent)) {\n    return markdownInfo;\n  }\n\n  const lfOffsetMapper = getLfNormalizedOffsetToOriginalOffsetMapper(noteContent);\n  markdownInfo.positionInNote.start.offset = lfOffsetMapper(markdownInfo.positionInNote.start.offset);\n  markdownInfo.positionInNote.end.offset = lfOffsetMapper(markdownInfo.positionInNote.end.offset);\n  return markdownInfo;\n}\n\n/**\n * The flushing counterpart of {@link getCodeBlockMarkdownInfo}, for the write helpers only.\n *\n * It saves the note first and reads the file, because a write helper compares the returned\n * `noteContent` against the file content {@link process} hands it: text taken from a dirty editor\n * would never match, and the provider would ask for a retry forever. A write is about to happen\n * anyway, so the save is not a write on an automatic trigger.\n *\n * @param params - The parameters for the function.\n * @returns The information about the code block, located in the saved file content.\n */\nasync function getCodeBlockMarkdownInfoAfterSave(params: GetCodeBlockMarkdownInfoParams): Promise<CodeBlockMarkdownInformation | null> {\n  const { app, context, el, source } = params;\n\n  const sourceFile = getFileOrNull({ app, pathOrFile: context.sourcePath });\n  assertNonNullable(sourceFile, `Source file ${context.sourcePath} not found.`);\n\n  await requestAnimationFrameAsync();\n  await saveNote(app, sourceFile);\n\n  let markdownInfo: CodeBlockMarkdownInformation | null = null;\n\n  await invokeWithFileSystemLock({\n    $function(noteContent) {\n      markdownInfo = findCodeBlockMarkdownInfo({ el, noteContent, source });\n    },\n    app,\n    pathOrFile: sourceFile\n  });\n\n  return markdownInfo;\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 getOpenMarkdownViewData(app: App, file: TFile): null | string {\n  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n    if (leaf.view instanceof MarkdownView && leaf.view.file?.path === file.path) {\n      return leaf.view.getViewData();\n    }\n  }\n\n  return null;\n}\n\nfunction insertText(params: InsertTextParams): string {\n  const { content, shouldPreserveLinePrefix = false, text } = params;\n  let { insertLineIndex } = params;\n\n  const lines = content.split('\\n');\n  const newLines = [...lines];\n  const textLines = text.split('\\n');\n\n  if (insertLineIndex < 0) {\n    insertLineIndex = 0;\n  }\n  if (insertLineIndex > lines.length) {\n    insertLineIndex = lines.length;\n  }\n\n  const PREFIX_LINE_REG_EXP = /^ {0,3}(?:> {1,3})*/g;\n  const match = (lines[insertLineIndex] ?? '').match(PREFIX_LINE_REG_EXP);\n  const linePrefix = match?.[0] ?? '';\n  newLines.splice(\n    insertLineIndex,\n    0,\n    ...(shouldPreserveLinePrefix\n      ? textLines.map((line) =>\n        indent({\n          prefix: linePrefix,\n          text: line\n        })\n      )\n      : textLines)\n  );\n  return newLines.join('\\n');\n}\n\nfunction isSuitableCodeBlock(params: IsSuitableCodeBlockParams): boolean {\n  const { isInCallout, language, match, sourceLf } = params;\n\n  const codeBlockLanguage = getMandatoryNamedGroup(match, 'CodeBlockLanguage');\n  if (codeBlockLanguage !== language) {\n    return false;\n  }\n\n  const linePrefix = getMandatoryNamedGroup(match, 'LinePrefix');\n\n  if (isInCallout && !linePrefix.includes('> ')) {\n    return false;\n  }\n\n  const codeBlockContent = getOptionalNamedGroup(match, 'CodeBlockContent') ?? '';\n  const cleanCodeBlockContent = codeBlockContent.split('\\n').map((line) => line.slice(linePrefix.length)).join('\\n');\n\n  return cleanCodeBlockContent === sourceLf;\n}\n\n/* v8 ignore stop */\n"],"mappings":"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","names":[]}

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

@@ -29,6 +29,13 @@ export interface FullRenderParams {
      * The Markdown string to render.
      */
     readonly markdown: string;
+    /**
+     * Whether to make the rendered headings and nested lists foldable, as in a Reading view. See
+     * {@link registerFoldHandlers}.
+     *
+     * @default `false`
+     */
+    readonly shouldRegisterFoldHandlers?: boolean;
     /**
      * Whether to register link handlers for the rendered element.
      *
@@ -192,7 +199,9 @@ export declare function fullRender(params: FullRenderParams): Promise<void>;
  */
 export declare function markdownToHtml(params: MarkdownToHtmlParams): Promise<string>;
 /**
- * Registers link handlers for the given element.
+ * Registers link handlers for the given element, so its links act as they do in a Reading view: click,
+ * mod-click, middle-click, drag, hover preview, the context menu, tags, and footnote links, which scroll
+ * to their footnote and back.
  *
  * @param params - The parameters for registering link handlers.
  */