obsidian-dev-utils 49.0.3 → 51.0.1

package/dist/lib/cjs/obsidian/markdown-code-block-processor.cjs

@@ -0,0 +1,362 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
+    if (globalThis?.app?.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markdown_code_block_processor_exports = {};
+__export(markdown_code_block_processor_exports, {
+  getCodeBlockMarkdownInfo: () => getCodeBlockMarkdownInfo,
+  insertAfterCodeBlock: () => insertAfterCodeBlock,
+  insertBeforeCodeBlock: () => insertBeforeCodeBlock,
+  removeCodeBlock: () => removeCodeBlock,
+  replaceCodeBlock: () => replaceCodeBlock
+});
+module.exports = __toCommonJS(markdown_code_block_processor_exports);
+var import_abort_controller = require('../abort-controller.cjs');
+var import_async = require('../async.cjs');
+var import_string = require('../string.cjs');
+var import_type_guards = require('../type-guards.cjs');
+var import_value_provider = require('../value-provider.cjs');
+var import_file_system = require('./file-system.cjs');
+var import_vault = require('./vault.cjs');
+async function getCodeBlockMarkdownInfo(params) {
+  const { app, ctx, el, source } = params;
+  const sourceFile = (0, import_file_system.getFileOrNull)(app, ctx.sourcePath);
+  (0, import_type_guards.assertNonNullable)(sourceFile, `Source file ${ctx.sourcePath} not found.`);
+  await (0, import_async.requestAnimationFrameAsync)();
+  await (0, import_vault.saveNote)(app, sourceFile);
+  let markdownInfo = null;
+  await (0, import_vault.invokeWithFileSystemLock)(app, sourceFile, (noteContent) => {
+    const noteContentLf = (0, import_string.ensureLfEndings)(noteContent);
+    const approximateSectionInfo = {
+      lineEnd: noteContentLf.split("\n").length - 1,
+      lineStart: 0,
+      text: noteContentLf
+    };
+    approximateSectionInfo.text = (0, import_string.ensureLfEndings)(approximateSectionInfo.text);
+    const sourceLf = (0, import_string.ensureLfEndings)(source);
+    if (!(0, import_string.hasSingleOccurrence)(noteContentLf, approximateSectionInfo.text)) {
+      return;
+    }
+    const sectionOffset = noteContentLf.indexOf(approximateSectionInfo.text);
+    const linesBeforeSectionCount = noteContentLf.slice(0, sectionOffset).split("\n").length - 1;
+    const isInCallout = !!el.parentElement?.classList.contains("callout-content");
+    const language = getLanguageFromElement(el);
+    const sourceLines = sourceLf.split("\n");
+    const textLines = approximateSectionInfo.text.split("\n");
+    const textLineOffsets = /* @__PURE__ */ new Map();
+    textLineOffsets.set(linesBeforeSectionCount, sectionOffset);
+    let lastTextLineOffset = sectionOffset;
+    for (let i = 0; i < textLines.length; i++) {
+      const textLine = textLines[i] ?? "";
+      const lineOffset = lastTextLineOffset + textLine.length + 1;
+      textLineOffsets.set(linesBeforeSectionCount + i + 1, lineOffset);
+      lastTextLineOffset = lineOffset;
+    }
+    const potentialCodeBlockTextLines = textLines.map(
+      (line, index) => approximateSectionInfo.lineStart <= index && index <= approximateSectionInfo.lineEnd ? line : ""
+    );
+    const potentialCodeBlockText = potentialCodeBlockTextLines.join("\n");
+    const REG_EXP = /(?<=^|\n)(?<LinePrefix> {0,3}(?:> {1,3})*)(?<CodeBlockStartDelimiter>(?<CodeBlockStartDelimiterChar>[`~])(?:\k<CodeBlockStartDelimiterChar>{2,}))(?<CodeBlockLanguage>\S*)(?:[ \t](?<CodeBlockArgs>.*?))?(?:\n(?<CodeBlockContent>(?:\n?\k<LinePrefix>.*)+?))?\n\k<LinePrefix>(?<CodeBlockEndDelimiter>\k<CodeBlockStartDelimiter>\k<CodeBlockStartDelimiterChar>*)[ \t]*(?=\n|$)/g;
+    for (const match of potentialCodeBlockText.matchAll(REG_EXP)) {
+      if (!isSuitableCodeBlock(match, language, sourceLf, isInCallout)) {
+        continue;
+      }
+      if (markdownInfo) {
+        return;
+      }
+      markdownInfo = createMarkdownInfoFromMatch({
+        approximateSectionInfo,
+        linesBeforeSectionCount,
+        match,
+        noteContent,
+        potentialCodeBlockText,
+        sourceLinesCount: sourceLines.length,
+        textLineOffsets
+      });
+    }
+    if (!markdownInfo) {
+      return;
+    }
+    if (noteContentLf === noteContent) {
+      return;
+    }
+    const lfOffsetMapper = (0, import_string.getLfNormalizedOffsetToOriginalOffsetMapper)(noteContent);
+    markdownInfo.positionInNote.start.offset = lfOffsetMapper(markdownInfo.positionInNote.start.offset);
+    markdownInfo.positionInNote.end.offset = lfOffsetMapper(markdownInfo.positionInNote.end.offset);
+  });
+  return markdownInfo;
+}
+async function insertAfterCodeBlock(params) {
+  const { app, ctx, lineOffset = 0, text } = params;
+  await (0, import_vault.process)(app, ctx.sourcePath, async (_abortSignal, content) => {
+    const markdownInfo = await getCodeBlockMarkdownInfo(params);
+    (0, import_type_guards.assertNonNullable)(markdownInfo, "Could not uniquely identify the code block.");
+    if (content !== markdownInfo.noteContent) {
+      return null;
+    }
+    const insertLineIndex = markdownInfo.positionInNote.end.line + lineOffset + 1;
+    return insertText(content, insertLineIndex, text, params.shouldPreserveLinePrefix);
+  });
+}
+async function insertBeforeCodeBlock(params) {
+  const { app, ctx, lineOffset = 0, text } = params;
+  await (0, import_vault.process)(app, ctx.sourcePath, async (_abortSignal, content) => {
+    const markdownInfo = await getCodeBlockMarkdownInfo(params);
+    if (!markdownInfo) {
+      throw new Error("Could not uniquely identify the code block.");
+    }
+    if (content !== markdownInfo.noteContent) {
+      return null;
+    }
+    const insertLineIndex = markdownInfo.positionInNote.start.line - lineOffset;
+    return insertText(content, insertLineIndex, text, params.shouldPreserveLinePrefix);
+  });
+}
+async function removeCodeBlock(params) {
+  await replaceCodeBlock({
+    ...params,
+    codeBlockProvider: "",
+    shouldKeepGapWhenEmpty: params.shouldKeepGap ?? false
+  });
+}
+async function replaceCodeBlock(params) {
+  const { app, codeBlockProvider, ctx } = params;
+  params.abortSignal?.throwIfAborted();
+  await (0, import_vault.process)(app, ctx.sourcePath, async (abortSignal, content) => {
+    abortSignal = (0, import_abort_controller.abortSignalAny)(abortSignal, params.abortSignal);
+    abortSignal.throwIfAborted();
+    const markdownInfo = await getCodeBlockMarkdownInfo(params);
+    if (!markdownInfo) {
+      throw new Error("Could not uniquely identify the code block.");
+    }
+    if (content !== markdownInfo.noteContent) {
+      return null;
+    }
+    let oldCodeBlock = content.slice(markdownInfo.positionInNote.start.offset, markdownInfo.positionInNote.end.offset);
+    if (params.shouldPreserveLinePrefix) {
+      oldCodeBlock = (0, import_string.unindent)(oldCodeBlock, markdownInfo.linePrefix);
+    }
+    let newCodeBlock = await (0, import_value_provider.resolveValue)(codeBlockProvider, abortSignal, oldCodeBlock);
+    abortSignal.throwIfAborted();
+    if ((newCodeBlock || params.shouldKeepGapWhenEmpty) && params.shouldPreserveLinePrefix) {
+      newCodeBlock = (0, import_string.indent)(newCodeBlock, markdownInfo.linePrefix);
+    }
+    const textBeforeCodeBlock = content.slice(0, markdownInfo.positionInNote.start.offset);
+    const textAfterCodeBlock = content.slice(markdownInfo.positionInNote.end.offset);
+    if (newCodeBlock || params.shouldKeepGapWhenEmpty) {
+      return `${textBeforeCodeBlock}${newCodeBlock}${textAfterCodeBlock}`;
+    }
+    if (!textBeforeCodeBlock && !textAfterCodeBlock) {
+      return "";
+    }
+    if (textBeforeCodeBlock) {
+      return `${textBeforeCodeBlock.slice(0, -1)}${textAfterCodeBlock}`;
+    }
+    return `${textBeforeCodeBlock}${textAfterCodeBlock.slice(1)}`;
+  });
+}
+function createMarkdownInfoFromMatch(params) {
+  const {
+    approximateSectionInfo,
+    linesBeforeSectionCount,
+    match,
+    noteContent,
+    potentialCodeBlockText,
+    sourceLinesCount,
+    textLineOffsets
+  } = params;
+  const linePrefix = match.groups?.["LinePrefix"] ?? "";
+  const codeBlockStartDelimiter = match.groups?.["CodeBlockStartDelimiter"] ?? "";
+  const codeBlockEndDelimiter = match.groups?.["CodeBlockEndDelimiter"] ?? "";
+  const codeBlockArgsStr = match.groups?.["CodeBlockArgs"] ?? "";
+  const language = match.groups?.["CodeBlockLanguage"] ?? "";
+  const previousText = potentialCodeBlockText.slice(0, match.index);
+  const previousTextLinesCount = previousText.split("\n").length - 1;
+  const startLine = linesBeforeSectionCount + previousTextLinesCount;
+  const endLine = startLine + sourceLinesCount + 1;
+  return {
+    args: codeBlockArgsStr.split(/\s+/).filter(Boolean),
+    endDelimiter: codeBlockEndDelimiter,
+    language,
+    linePrefix,
+    noteContent,
+    positionInNote: {
+      end: {
+        col: (textLineOffsets.get(endLine + 1) ?? 0) - (textLineOffsets.get(endLine) ?? 0) - 1,
+        line: endLine,
+        offset: (textLineOffsets.get(endLine + 1) ?? 0) - 1
+      },
+      start: {
+        col: 0,
+        line: startLine,
+        offset: textLineOffsets.get(startLine) ?? 0
+      }
+    },
+    rawArgsStr: codeBlockArgsStr,
+    sectionInfo: {
+      lineEnd: previousTextLinesCount + sourceLinesCount + 1,
+      lineStart: previousTextLinesCount,
+      text: approximateSectionInfo.text
+    },
+    startDelimiter: codeBlockStartDelimiter
+  };
+}
+function getLanguageFromElement(el) {
+  const BLOCK_LANGUAGE_PREFIX = "block-language-";
+  return Array.from(el.classList).find((cls) => cls.startsWith(BLOCK_LANGUAGE_PREFIX))?.slice(BLOCK_LANGUAGE_PREFIX.length) ?? "";
+}
+function insertText(content, insertLineIndex, text, shouldPreserveLinePrefix) {
+  const lines = content.split("\n");
+  const newLines = lines.slice();
+  const textLines = text.split("\n");
+  if (insertLineIndex < 0) {
+    insertLineIndex = 0;
+  }
+  if (insertLineIndex > lines.length) {
+    insertLineIndex = lines.length;
+  }
+  const PREFIX_LINE_REG_EXP = /^ {0,3}(?:> {1,3})*/g;
+  const match = (lines[insertLineIndex] ?? "").match(PREFIX_LINE_REG_EXP);
+  const linePrefix = match?.[0] ?? "";
+  newLines.splice(insertLineIndex, 0, ...shouldPreserveLinePrefix ? textLines.map((line) => (0, import_string.indent)(line, linePrefix)) : textLines);
+  return newLines.join("\n");
+}
+function isSuitableCodeBlock(match, language, sourceLf, isInCallout) {
+  const codeBlockLanguage = match.groups?.["CodeBlockLanguage"] ?? "";
+  if (codeBlockLanguage !== language) {
+    return false;
+  }
+  const linePrefix = match.groups?.["LinePrefix"] ?? "";
+  if (isInCallout && !linePrefix.includes("> ")) {
+    return false;
+  }
+  const codeBlockContent = match.groups?.["CodeBlockContent"] ?? "";
+  const cleanCodeBlockContent = codeBlockContent.split("\n").map((line) => line.slice(linePrefix.length)).join("\n");
+  return cleanCodeBlockContent === sourceLf;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCodeBlockMarkdownInfo,
+  insertAfterCodeBlock,
+  insertBeforeCodeBlock,
+  removeCodeBlock,
+  replaceCodeBlock
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/markdown-code-block-processor.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\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 {\n  App,\n  MarkdownPostProcessorContext,\n  MarkdownSectionInformation\n} from 'obsidian';\n\nimport type { ValueProvider } from '../value-provider.ts';\nimport type { CodeBlockMarkdownInformation } from './code-block-markdown-information.ts';\n\nimport { abortSignalAny } from '../abort-controller.ts';\nimport { requestAnimationFrameAsync } from '../async.ts';\nimport {\n  ensureLfEndings,\n  getLfNormalizedOffsetToOriginalOffsetMapper,\n  hasSingleOccurrence,\n  indent,\n  unindent\n} from '../string.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport { resolveValue } from '../value-provider.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 ctx: 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. Default is `0`.\n   */\n  readonly lineOffset?: number;\n\n  /**\n   * Whether to preserve the line prefix of the code block. Default is `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   * Whether to keep the gap after removing the code block. Default is `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, [string]>;\n\n  /**\n   * Whether to keep the gap when the new code block is empty. Default is `false`.\n   */\n  readonly shouldKeepGapWhenEmpty?: boolean;\n\n  /**\n   * Whether to preserve the line prefix of the code block. Default is `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\n/**\n * Gets the information about a code block in a Markdown section.\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, ctx, el, source } = params;\n\n  const sourceFile = getFileOrNull(app, ctx.sourcePath);\n  assertNonNullable(sourceFile, `Source file ${ctx.sourcePath} not found.`);\n\n  await requestAnimationFrameAsync();\n  await saveNote(app, sourceFile);\n\n  let markdownInfo: CodeBlockMarkdownInformation | null = null;\n\n  await invokeWithFileSystemLock(app, sourceFile, (noteContent) => {\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    const sourceLf = ensureLfEndings(source);\n\n    if (!hasSingleOccurrence(noteContentLf, approximateSectionInfo.text)) {\n      return;\n    }\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>();\n    textLineOffsets.set(linesBeforeSectionCount, sectionOffset);\n\n    let lastTextLineOffset = sectionOffset;\n    for (let i = 0; i < textLines.length; i++) {\n      const textLine = textLines[i] ?? '';\n      const lineOffset = lastTextLineOffset + textLine.length + 1;\n      textLineOffsets.set(linesBeforeSectionCount + i + 1, lineOffset);\n      lastTextLineOffset = lineOffset;\n    }\n\n    const potentialCodeBlockTextLines = textLines.map((line, index) =>\n      approximateSectionInfo.lineStart <= index && index <= approximateSectionInfo.lineEnd ? line : ''\n    );\n    const potentialCodeBlockText = potentialCodeBlockTextLines.join('\\n');\n\n    const REG_EXP =\n      /(?<=^|\\n)(?<LinePrefix> {0,3}(?:> {1,3})*)(?<CodeBlockStartDelimiter>(?<CodeBlockStartDelimiterChar>[`~])(?:\\k<CodeBlockStartDelimiterChar>{2,}))(?<CodeBlockLanguage>\\S*)(?:[ \\t](?<CodeBlockArgs>.*?))?(?:\\n(?<CodeBlockContent>(?:\\n?\\k<LinePrefix>.*)+?))?\\n\\k<LinePrefix>(?<CodeBlockEndDelimiter>\\k<CodeBlockStartDelimiter>\\k<CodeBlockStartDelimiterChar>*)[ \\t]*(?=\\n|$)/g;\n\n    for (const match of potentialCodeBlockText.matchAll(REG_EXP)) {\n      if (!isSuitableCodeBlock(match, language, sourceLf, isInCallout)) {\n        continue;\n      }\n\n      if (markdownInfo) {\n        return;\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) {\n      return;\n    }\n\n    if (noteContentLf === noteContent) {\n      return;\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  });\n\n  return markdownInfo;\n}\n\n/**\n * Inserts text after the code block.\n *\n * @param params - The parameters for the function.\n */\nexport async function insertAfterCodeBlock(params: InsertCodeBlockParams): Promise<void> {\n  const { app, ctx, lineOffset = 0, text } = params;\n\n  await process(app, ctx.sourcePath, async (_abortSignal, content) => {\n    const markdownInfo = await getCodeBlockMarkdownInfo(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(content, insertLineIndex, text, params.shouldPreserveLinePrefix);\n  });\n}\n\n/**\n * Inserts text before the code block.\n *\n * @param params - The parameters for the function.\n */\nexport async function insertBeforeCodeBlock(params: InsertCodeBlockParams): Promise<void> {\n  const { app, ctx, lineOffset = 0, text } = params;\n\n  await process(app, ctx.sourcePath, async (_abortSignal, content) => {\n    const markdownInfo = await getCodeBlockMarkdownInfo(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(content, insertLineIndex, text, params.shouldPreserveLinePrefix);\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, ctx } = params;\n  params.abortSignal?.throwIfAborted();\n\n  await process(app, ctx.sourcePath, async (abortSignal, content) => {\n    abortSignal = abortSignalAny(abortSignal, params.abortSignal);\n    abortSignal.throwIfAborted();\n    const markdownInfo = await getCodeBlockMarkdownInfo(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(oldCodeBlock, markdownInfo.linePrefix);\n    }\n\n    let newCodeBlock = await resolveValue(codeBlockProvider, abortSignal, oldCodeBlock);\n    abortSignal.throwIfAborted();\n    if ((newCodeBlock || params.shouldKeepGapWhenEmpty) && params.shouldPreserveLinePrefix) {\n      newCodeBlock = indent(newCodeBlock, markdownInfo.linePrefix);\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    if (textBeforeCodeBlock) {\n      return `${textBeforeCodeBlock.slice(0, -1)}${textAfterCodeBlock}`;\n    }\n\n    return `${textBeforeCodeBlock}${textAfterCodeBlock.slice(1)}`;\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 = match.groups?.['LinePrefix'] ?? '';\n  const codeBlockStartDelimiter = match.groups?.['CodeBlockStartDelimiter'] ?? '';\n  const codeBlockEndDelimiter = match.groups?.['CodeBlockEndDelimiter'] ?? '';\n  const codeBlockArgsStr = match.groups?.['CodeBlockArgs'] ?? '';\n  const language = match.groups?.['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    args: codeBlockArgsStr.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    rawArgsStr: codeBlockArgsStr,\n    sectionInfo: {\n      lineEnd: previousTextLinesCount + sourceLinesCount + 1,\n      lineStart: previousTextLinesCount,\n      text: approximateSectionInfo.text\n    },\n    startDelimiter: codeBlockStartDelimiter\n  };\n}\n\nfunction getLanguageFromElement(el: HTMLElement): string {\n  const BLOCK_LANGUAGE_PREFIX = 'block-language-';\n  return Array.from(el.classList).find((cls) => cls.startsWith(BLOCK_LANGUAGE_PREFIX))?.slice(BLOCK_LANGUAGE_PREFIX.length) ?? '';\n}\n\nfunction insertText(content: string, insertLineIndex: number, text: string, shouldPreserveLinePrefix?: boolean): string {\n  const lines = content.split('\\n');\n  const newLines = lines.slice();\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(insertLineIndex, 0, ...(shouldPreserveLinePrefix ? textLines.map((line) => indent(line, linePrefix)) : textLines));\n  return newLines.join('\\n');\n}\n\nfunction isSuitableCodeBlock(\n  match: RegExpMatchArray,\n  language: string,\n  sourceLf: string,\n  isInCallout: boolean\n): boolean {\n  const codeBlockLanguage = match.groups?.['CodeBlockLanguage'] ?? '';\n  if (codeBlockLanguage !== language) {\n    return false;\n  }\n\n  const linePrefix = match.groups?.['LinePrefix'] ?? '';\n\n  if (isInCallout && !linePrefix.includes('> ')) {\n    return false;\n  }\n\n  const codeBlockContent = match.groups?.['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/cjs/obsidian/markdown-code-block-processor.d.cts

@@ -0,0 +1,107 @@
+/**
+ * @packageDocumentation
+ *
+ * This module provides utility functions for processing code blocks in Obsidian.
+ */
+import type { App, MarkdownPostProcessorContext } from 'obsidian';
+import type { ValueProvider } from '../value-provider.cjs';
+import type { CodeBlockMarkdownInformation } from './code-block-markdown-information.cjs';
+/**
+ * Options for {@link getCodeBlockMarkdownInfo}.
+ */
+export interface GetCodeBlockMarkdownInfoParams {
+    /**
+     * An Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * A {@link MarkdownPostProcessorContext} object.
+     */
+    readonly ctx: MarkdownPostProcessorContext;
+    /**
+     * A {@link HTMLElement} representing the code block.
+     */
+    readonly el: HTMLElement;
+    /**
+     * A source of the code block.
+     */
+    readonly source: string;
+}
+/**
+ * Options for {@link insertAfterCodeBlock} / {@link insertBeforeCodeBlock}.
+ */
+export interface InsertCodeBlockParams extends GetCodeBlockMarkdownInfoParams {
+    /**
+     * A number of lines to offset the insertion by. Default is `0`.
+     */
+    readonly lineOffset?: number;
+    /**
+     * Whether to preserve the line prefix of the code block. Default is `false`.
+     */
+    readonly shouldPreserveLinePrefix?: boolean;
+    /**
+     * A text to insert after the code block.
+     */
+    readonly text: string;
+}
+/**
+ * Options for {@link removeCodeBlock}.
+ */
+export interface RemoveCodeBlockParams extends GetCodeBlockMarkdownInfoParams {
+    /**
+     * Whether to keep the gap after removing the code block. Default is `false`.
+     */
+    readonly shouldKeepGap?: boolean;
+}
+/**
+ * Options for {@link replaceCodeBlock}.
+ */
+export interface ReplaceCodeBlockParams extends GetCodeBlockMarkdownInfoParams {
+    /**
+     * An abort signal to control the execution of the function.
+     */
+    readonly abortSignal?: AbortSignal;
+    /**
+     * Provides a new code block.
+     */
+    readonly codeBlockProvider: ValueProvider<string, [string]>;
+    /**
+     * Whether to keep the gap when the new code block is empty. Default is `false`.
+     */
+    readonly shouldKeepGapWhenEmpty?: boolean;
+    /**
+     * Whether to preserve the line prefix of the code block. Default is `false`.
+     */
+    readonly shouldPreserveLinePrefix?: boolean;
+}
+/**
+ * Gets the information about a code block in a Markdown section.
+ *
+ * @param params - The parameters for the function.
+ * @returns The information about the code block in the Markdown section.
+ */
+export declare function getCodeBlockMarkdownInfo(params: GetCodeBlockMarkdownInfoParams): Promise<CodeBlockMarkdownInformation | null>;
+/**
+ * Inserts text after the code block.
+ *
+ * @param params - The parameters for the function.
+ */
+export declare function insertAfterCodeBlock(params: InsertCodeBlockParams): Promise<void>;
+/**
+ * Inserts text before the code block.
+ *
+ * @param params - The parameters for the function.
+ */
+export declare function insertBeforeCodeBlock(params: InsertCodeBlockParams): Promise<void>;
+/**
+ * Removes the code block.
+ *
+ * @param params - The parameters for the function.
+ */
+export declare function removeCodeBlock(params: RemoveCodeBlockParams): Promise<void>;
+/**
+ * Replaces the code block.
+ *
+ * @param params - The parameters for the function.
+ */
+export declare function replaceCodeBlock(params: ReplaceCodeBlockParams): Promise<void>;

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

@@ -0,0 +1,140 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
+    if (globalThis?.app?.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markdown_view_exports = {};
+__export(markdown_view_exports, {
+  getFullContentHtml: () => getFullContentHtml
+});
+module.exports = __toCommonJS(markdown_view_exports);
+function getFullContentHtml(view) {
+  const codeMirror = view.editor.cm;
+  codeMirror.viewState.printing = true;
+  codeMirror.measure();
+  const html = view.contentEl.innerHTML;
+  codeMirror.viewState.printing = false;
+  codeMirror.measure();
+  return html;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFullContentHtml
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL21hcmtkb3duLXZpZXcudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKlxuICogVXRpbGl0aWVzIGZvciB3b3JraW5nIHdpdGggTWFya2Rvd25WaWV3XG4gKi9cblxuaW1wb3J0IHR5cGUgeyBNYXJrZG93blZpZXcgfSBmcm9tICdvYnNpZGlhbic7XG5cbi8qKlxuICogR2V0IHRoZSBmdWxsIEhUTUwgY29udGVudCBvZiB0aGUgY3VycmVudCBNYXJrZG93blZpZXdcbiAqXG4gKiBAcGFyYW0gdmlldyAtIFRoZSBNYXJrZG93blZpZXcgdG8gZ2V0IHRoZSBIVE1MIGZyb21cbiAqIEByZXR1cm5zIFRoZSBmdWxsIEhUTUwgb2YgdGhlIE1hcmtkb3duVmlld1xuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0RnVsbENvbnRlbnRIdG1sKHZpZXc6IE1hcmtkb3duVmlldyk6IHN0cmluZyB7XG4gIGNvbnN0IGNvZGVNaXJyb3IgPSB2aWV3LmVkaXRvci5jbTtcbiAgY29kZU1pcnJvci52aWV3U3RhdGUucHJpbnRpbmcgPSB0cnVlO1xuICBjb2RlTWlycm9yLm1lYXN1cmUoKTtcbiAgY29uc3QgaHRtbCA9IHZpZXcuY29udGVudEVsLmlubmVySFRNTDtcbiAgY29kZU1pcnJvci52aWV3U3RhdGUucHJpbnRpbmcgPSBmYWxzZTtcbiAgY29kZU1pcnJvci5tZWFzdXJlKCk7XG4gIHJldHVybiBodG1sO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFjTyxTQUFTLG1CQUFtQixNQUE0QjtBQUM3RCxRQUFNLGFBQWEsS0FBSyxPQUFPO0FBQy9CLGFBQVcsVUFBVSxXQUFXO0FBQ2hDLGFBQVcsUUFBUTtBQUNuQixRQUFNLE9BQU8sS0FBSyxVQUFVO0FBQzVCLGFBQVcsVUFBVSxXQUFXO0FBQ2hDLGFBQVcsUUFBUTtBQUNuQixTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbXQp9Cg==