obsidian-dev-utils 33.1.0 → 34.0.0

package/dist/lib/esm/obsidian/MarkdownCodeBlockProcessor.mjs

@@ -5,44 +5,179 @@ if you want to view the source, please visit the github repository of this plugi
 
 (function initEsm(){if(globalThis.process){return}const browserProcess={browser:true,cwd:__name(()=>"/","cwd"),env:{},platform:"android"};globalThis.process=browserProcess})();
 
-import { parse } from "shell-quote";
+import { getFrontMatterInfo } from "obsidian";
 import { abortSignalNever } from "../AbortController.mjs";
-import { throwExpression } from "../Error.mjs";
-import { replaceAll } from "../String.mjs";
+import {
+  hasSingleOccurrence,
+  indent,
+  replaceAll,
+  unindent
+} from "../String.mjs";
 import { resolveValue } from "../ValueProvider.mjs";
 import { process } from "./Vault.mjs";
-function getCodeBlockArguments(ctx, el) {
-  const sectionInfo = ctx.getSectionInfo(el);
-  if (!sectionInfo) {
-    return [];
+async function getCodeBlockSectionInfo(options) {
+  const { app, ctx, el, source } = options;
+  const approximateSectionInfo = ctx.getSectionInfo(el) ?? await createApproximateSectionInfo(app, ctx);
+  const isInCallout = !!el.parentElement?.classList.contains("callout-content");
+  const language = getLanguageFromElement(el);
+  const sourceLines = source.split("\n");
+  const textLines = approximateSectionInfo.text.split("\n");
+  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>.*?)[ \t]+)?(?:\n(?<CodeBlockContent>(?:\n?\k<LinePrefix>.*)+?))?\n\k<LinePrefix>(?<CodeBlockEndDelimiter>\k<CodeBlockStartDelimiter>\k<CodeBlockStartDelimiterChar>*)[ \t]*(?:\n|$)/g;
+  let sectionInfo = null;
+  for (const match of potentialCodeBlockText.matchAll(REG_EXP)) {
+    if (!isSuitableCodeBlock(match, language, source, isInCallout)) {
+      continue;
+    }
+    if (sectionInfo) {
+      throw new Error("Multiple suitable code blocks found.");
+    }
+    sectionInfo = createSectionInfoFromMatch(potentialCodeBlockText, match, approximateSectionInfo, sourceLines);
   }
-  const lines = sectionInfo.text.split("\n");
-  const codeBlockHeader = lines[sectionInfo.lineStart] ?? throwExpression(new Error("Code block header not found"));
-  const match = /^(?:`{3,}|~{3,})\S+\s+(?<Arguments>.*)$/.exec(codeBlockHeader);
-  if (!match) {
-    return [];
+  if (!sectionInfo) {
+    throw new Error("No suitable code block found.");
   }
-  return parse(match.groups?.["Arguments"] ?? "").map(String);
+  return sectionInfo;
+}
+async function insertAfterCodeBlock(options) {
+  const { app, ctx, lineOffset = 0, text } = options;
+  const sectionInfo = await getCodeBlockSectionInfo(options);
+  await process(app, ctx.sourcePath, (_abortSignal, content) => {
+    if (!hasSingleOccurrence(content, sectionInfo.text)) {
+      throw new Error("Multiple suitable code blocks found.");
+    }
+    const index = content.indexOf(sectionInfo.text);
+    const textBeforeSection = content.slice(0, index);
+    const linesBeforeSection = textBeforeSection.split("\n");
+    const insertLineIndex = linesBeforeSection.length + sectionInfo.lineEnd + lineOffset;
+    return insertText(content, insertLineIndex, text, options.shouldPreserveLinePrefix);
+  });
+}
+async function insertBeforeCodeBlock(options) {
+  const { app, ctx, lineOffset = 0, text } = options;
+  const sectionInfo = await getCodeBlockSectionInfo(options);
+  await process(app, ctx.sourcePath, (_abortSignal, content) => {
+    if (!hasSingleOccurrence(content, sectionInfo.text)) {
+      throw new Error("Multiple suitable code blocks found.");
+    }
+    const index = content.indexOf(sectionInfo.text);
+    const textBeforeSection = content.slice(0, index);
+    const linesBeforeSection = textBeforeSection.split("\n");
+    const insertLineIndex = linesBeforeSection.length + sectionInfo.lineStart - lineOffset - 1;
+    return insertText(content, insertLineIndex, text, options.shouldPreserveLinePrefix);
+  });
+}
+async function removeCodeBlock(options) {
+  await replaceCodeBlock({
+    ...options,
+    codeBlockProvider: ""
+  });
 }
-async function replaceCodeBlock(app, ctx, el, codeBlockProvider, abortSignal) {
-  abortSignal ??= abortSignalNever();
+async function replaceCodeBlock(options) {
+  const { app, codeBlockProvider, ctx } = options;
+  const abortSignal = options.abortSignal ?? abortSignalNever();
   abortSignal.throwIfAborted();
-  const sectionInfo = ctx.getSectionInfo(el);
-  if (!sectionInfo) {
-    return;
-  }
+  const sectionInfo = await getCodeBlockSectionInfo(options);
   const lines = sectionInfo.text.split("\n");
-  const prefix = lines.slice(0, sectionInfo.lineStart).join("\n");
-  const oldCodeBlock = lines.slice(sectionInfo.lineStart, sectionInfo.lineEnd + 1).join("\n");
-  const suffix = lines.slice(sectionInfo.lineEnd + 1).join("\n");
-  const newCodeBlock = await resolveValue(codeBlockProvider, abortSignal, oldCodeBlock);
+  const textBeforeCodeBlock = lines.slice(0, sectionInfo.lineStart).join("\n");
+  let oldCodeBlock = lines.slice(sectionInfo.lineStart, sectionInfo.lineEnd + 1).join("\n");
+  if (options.shouldPreserveLinePrefix) {
+    oldCodeBlock = unindent(oldCodeBlock, sectionInfo.prefix);
+  }
+  const textAfterCodeBlock = lines.slice(sectionInfo.lineEnd + 1).join("\n");
+  let newCodeBlock = await resolveValue(codeBlockProvider, abortSignal, oldCodeBlock);
   abortSignal.throwIfAborted();
-  const newSectionText = `${prefix}
-${newCodeBlock}${newCodeBlock ? "\n" : ""}${suffix}`;
-  await process(app, ctx.sourcePath, (_abortSignal, content) => replaceAll(content, sectionInfo.text, newSectionText));
+  if (newCodeBlock && options.shouldPreserveLinePrefix) {
+    newCodeBlock = indent(newCodeBlock, sectionInfo.prefix);
+  }
+  const newSectionText = `${appendNewLine(textBeforeCodeBlock)}${appendNewLine(newCodeBlock)}${textAfterCodeBlock}`;
+  await process(app, ctx.sourcePath, (_abortSignal, content) => {
+    if (!hasSingleOccurrence(content, sectionInfo.text)) {
+      throw new Error("Multiple suitable code blocks found.");
+    }
+    return replaceAll(content, sectionInfo.text, newSectionText);
+  });
+}
+function appendNewLine(text) {
+  return text === "" ? "" : `${text}
+`;
+}
+async function createApproximateSectionInfo(app, ctx) {
+  const sourceFile = app.vault.getFileByPath(ctx.sourcePath);
+  if (!sourceFile) {
+    throw new Error(`Source file ${ctx.sourcePath} not found.`);
+  }
+  const cache = app.metadataCache.getFileCache(sourceFile);
+  const frontmatterEndOffset = cache?.frontmatterPosition?.end.offset;
+  const content = await app.vault.cachedRead(sourceFile);
+  const contentStartOffset = frontmatterEndOffset === void 0 ? getFrontMatterInfo(content).contentStart : frontmatterEndOffset + 1;
+  const text = content.slice(contentStartOffset);
+  return {
+    lineEnd: text.split("\n").length - 1,
+    lineStart: 0,
+    text
+  };
+}
+function createSectionInfoFromMatch(potentialCodeBlockText, match, approximateSectionInfo, sourceLines) {
+  const linePrefix = match.groups?.["LinePrefix"] ?? "";
+  const codeBlockStartDelimiter = match.groups?.["CodeBlockStartDelimiter"] ?? "";
+  const codeBlockEndDelimiter = match.groups?.["CodeBlockEndDelimiter"] ?? "";
+  const codeBlockArgs = match.groups?.["CodeBlockArgs"] ?? "";
+  const language = match.groups?.["CodeBlockLanguage"] ?? "";
+  const previousText = potentialCodeBlockText.slice(0, match.index);
+  const previousTextLines = previousText.split("\n");
+  return {
+    args: codeBlockArgs,
+    endDelimiter: codeBlockEndDelimiter,
+    language,
+    lineEnd: previousTextLines.length + sourceLines.length,
+    lineStart: previousTextLines.length - 1,
+    prefix: linePrefix,
+    startDelimiter: codeBlockStartDelimiter,
+    text: approximateSectionInfo.text
+  };
+}
+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) => indent(line, linePrefix)) : textLines);
+  return newLines.join("\n");
+}
+function isSuitableCodeBlock(match, language, source, 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 === source;
 }
 export {
-  getCodeBlockArguments,
+  getCodeBlockSectionInfo,
+  insertAfterCodeBlock,
+  insertBeforeCodeBlock,
+  removeCodeBlock,
   replaceCodeBlock
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/MarkdownCodeBlockProcessor.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * This module provides utility functions for processing code blocks in Obsidian.\n */\n\nimport type {\n  App,\n  MarkdownPostProcessorContext,\n  MarkdownSectionInformation\n} from 'obsidian';\n\nimport { getFrontMatterInfo } from 'obsidian';\n\nimport type { ValueProvider } from '../ValueProvider.ts';\n\nimport { abortSignalNever } from '../AbortController.ts';\nimport {\n  hasSingleOccurrence,\n  indent,\n  replaceAll,\n  unindent\n} from '../String.ts';\nimport { resolveValue } from '../ValueProvider.ts';\nimport { process } from './Vault.ts';\n\n/**\n * Represents the information about a code block in a Markdown section.\n */\nexport interface CodeBlockMarkdownSectionInformation extends MarkdownSectionInformation {\n  /**\n   * The arguments of the code block.\n   */\n  args: string;\n\n  /**\n   * The end delimiter of the code block.\n   */\n  endDelimiter: string;\n\n  /**\n   * The language of the code block.\n   */\n  language: string;\n\n  /**\n   * The prefix of the code block.\n   */\n  prefix: string;\n\n  /**\n   * The start delimiter of the code block.\n   */\n  startDelimiter: string;\n}\n\n/**\n * Represents the options for getting the information about a code block in a Markdown section.\n */\nexport interface GetCodeBlockSectionInfoOptions {\n  /**\n   * The Obsidian App object.\n   */\n  app: App;\n\n  /**\n   * The MarkdownPostProcessorContext object.\n   */\n  ctx: MarkdownPostProcessorContext;\n\n  /**\n   * The HTMLElement representing the code block.\n   */\n  el: HTMLElement;\n\n  /**\n   * The source of the code block.\n   */\n  source: string;\n}\n\n/**\n * Represents the options for inserting text after a code block.\n */\nexport interface InsertCodeBlockOptions extends GetCodeBlockSectionInfoOptions {\n  /**\n   * The number of lines to offset the insertion by. Default is `0`.\n   */\n  lineOffset?: number;\n\n  /**\n   * Whether to preserve the line prefix of the code block. Default is `false`.\n   */\n  shouldPreserveLinePrefix?: boolean;\n\n  /**\n   * The text to insert after the code block.\n   */\n  text: string;\n}\n\n/**\n * Represents the options for replacing a code block.\n */\nexport interface ReplaceCodeBlockOptions extends GetCodeBlockSectionInfoOptions {\n  /**\n   * The abort signal to control the execution of the function.\n   */\n  abortSignal?: AbortSignal;\n\n  /**\n   * The provider that provides the new code block.\n   */\n  codeBlockProvider: ValueProvider<string, [string]>;\n\n  /**\n   * Whether to preserve the line prefix of the code block. Default is `false`.\n   */\n  shouldPreserveLinePrefix?: boolean;\n}\n\n/**\n * Gets the information about a code block in a Markdown section.\n *\n * @param options - The options for the function.\n * @returns The information about the code block in the Markdown section.\n *\n * @throws If no suitable code block is found.\n * @throws If multiple suitable code blocks are found. Happens when the code block is in a callout. Caused by the bug in Obsidian: {@link https://forum.obsidian.md/t/bug-getsectioninfo-is-inaccurate-inside-callouts/104289}\n */\nexport async function getCodeBlockSectionInfo(options: GetCodeBlockSectionInfoOptions): Promise<CodeBlockMarkdownSectionInformation> {\n  const { app, ctx, el, source } = options;\n\n  const approximateSectionInfo = ctx.getSectionInfo(el) ?? await createApproximateSectionInfo(app, ctx);\n  const isInCallout = !!el.parentElement?.classList.contains('callout-content');\n\n  const language = getLanguageFromElement(el);\n  const sourceLines = source.split('\\n');\n\n  const textLines = approximateSectionInfo.text.split('\\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>.*?)[ \\t]+)?(?:\\n(?<CodeBlockContent>(?:\\n?\\k<LinePrefix>.*)+?))?\\n\\k<LinePrefix>(?<CodeBlockEndDelimiter>\\k<CodeBlockStartDelimiter>\\k<CodeBlockStartDelimiterChar>*)[ \\t]*(?:\\n|$)/g;\n\n  let sectionInfo: CodeBlockMarkdownSectionInformation | null = null;\n\n  for (const match of potentialCodeBlockText.matchAll(REG_EXP)) {\n    if (!isSuitableCodeBlock(match, language, source, isInCallout)) {\n      continue;\n    }\n\n    if (sectionInfo) {\n      throw new Error('Multiple suitable code blocks found.');\n    }\n\n    sectionInfo = createSectionInfoFromMatch(potentialCodeBlockText, match, approximateSectionInfo, sourceLines);\n  }\n\n  if (!sectionInfo) {\n    throw new Error('No suitable code block found.');\n  }\n\n  return sectionInfo;\n}\n\n/**\n * Inserts text after the code block.\n *\n * @param options - The options for the function.\n */\nexport async function insertAfterCodeBlock(options: InsertCodeBlockOptions): Promise<void> {\n  const { app, ctx, lineOffset = 0, text } = options;\n\n  const sectionInfo = await getCodeBlockSectionInfo(options);\n  await process(app, ctx.sourcePath, (_abortSignal, content) => {\n    if (!hasSingleOccurrence(content, sectionInfo.text)) {\n      throw new Error('Multiple suitable code blocks found.');\n    }\n\n    const index = content.indexOf(sectionInfo.text);\n    const textBeforeSection = content.slice(0, index);\n    const linesBeforeSection = textBeforeSection.split('\\n');\n    const insertLineIndex = linesBeforeSection.length + sectionInfo.lineEnd + lineOffset;\n    return insertText(content, insertLineIndex, text, options.shouldPreserveLinePrefix);\n  });\n}\n\n/**\n * Inserts text before the code block.\n *\n * @param options - The options for the function.\n */\nexport async function insertBeforeCodeBlock(options: InsertCodeBlockOptions): Promise<void> {\n  const { app, ctx, lineOffset = 0, text } = options;\n\n  const sectionInfo = await getCodeBlockSectionInfo(options);\n  await process(app, ctx.sourcePath, (_abortSignal, content) => {\n    if (!hasSingleOccurrence(content, sectionInfo.text)) {\n      throw new Error('Multiple suitable code blocks found.');\n    }\n\n    const index = content.indexOf(sectionInfo.text);\n    const textBeforeSection = content.slice(0, index);\n    const linesBeforeSection = textBeforeSection.split('\\n');\n    const insertLineIndex = linesBeforeSection.length + sectionInfo.lineStart - lineOffset - 1;\n    return insertText(content, insertLineIndex, text, options.shouldPreserveLinePrefix);\n  });\n}\n\n/**\n * Removes the code block.\n *\n * @param options - The options for the function.\n */\nexport async function removeCodeBlock(options: GetCodeBlockSectionInfoOptions): Promise<void> {\n  await replaceCodeBlock({\n    ...options,\n    codeBlockProvider: ''\n  });\n}\n\n/**\n * Replaces the code block.\n *\n * @param options - The options for the function.\n */\nexport async function replaceCodeBlock(options: ReplaceCodeBlockOptions): Promise<void> {\n  const { app, codeBlockProvider, ctx } = options;\n\n  const abortSignal = options.abortSignal ?? abortSignalNever();\n  abortSignal.throwIfAborted();\n\n  const sectionInfo = await getCodeBlockSectionInfo(options);\n\n  const lines = sectionInfo.text.split('\\n');\n  const textBeforeCodeBlock = lines.slice(0, sectionInfo.lineStart).join('\\n');\n  let oldCodeBlock = lines.slice(sectionInfo.lineStart, sectionInfo.lineEnd + 1).join('\\n');\n  if (options.shouldPreserveLinePrefix) {\n    oldCodeBlock = unindent(oldCodeBlock, sectionInfo.prefix);\n  }\n  const textAfterCodeBlock = lines.slice(sectionInfo.lineEnd + 1).join('\\n');\n  let newCodeBlock = await resolveValue(codeBlockProvider, abortSignal, oldCodeBlock);\n  abortSignal.throwIfAborted();\n\n  if (newCodeBlock && options.shouldPreserveLinePrefix) {\n    newCodeBlock = indent(newCodeBlock, sectionInfo.prefix);\n  }\n\n  const newSectionText = `${appendNewLine(textBeforeCodeBlock)}${appendNewLine(newCodeBlock)}${textAfterCodeBlock}`;\n  await process(app, ctx.sourcePath, (_abortSignal, content) => {\n    if (!hasSingleOccurrence(content, sectionInfo.text)) {\n      throw new Error('Multiple suitable code blocks found.');\n    }\n    return replaceAll(content, sectionInfo.text, newSectionText);\n  });\n}\n\nfunction appendNewLine(text: string): string {\n  return text === '' ? '' : `${text}\\n`;\n}\n\nasync function createApproximateSectionInfo(app: App, ctx: MarkdownPostProcessorContext): Promise<MarkdownSectionInformation> {\n  const sourceFile = app.vault.getFileByPath(ctx.sourcePath);\n  if (!sourceFile) {\n    throw new Error(`Source file ${ctx.sourcePath} not found.`);\n  }\n  const cache = app.metadataCache.getFileCache(sourceFile);\n  const frontmatterEndOffset = cache?.frontmatterPosition?.end.offset;\n  const content = await app.vault.cachedRead(sourceFile);\n  const contentStartOffset = frontmatterEndOffset === undefined ? getFrontMatterInfo(content).contentStart : frontmatterEndOffset + 1;\n  const text = content.slice(contentStartOffset);\n  return {\n    lineEnd: text.split('\\n').length - 1,\n    lineStart: 0,\n    text\n  };\n}\n\nfunction createSectionInfoFromMatch(\n  potentialCodeBlockText: string,\n  match: RegExpMatchArray,\n  approximateSectionInfo: MarkdownSectionInformation,\n  sourceLines: string[]\n): CodeBlockMarkdownSectionInformation {\n  const linePrefix = match.groups?.['LinePrefix'] ?? '';\n  const codeBlockStartDelimiter = match.groups?.['CodeBlockStartDelimiter'] ?? '';\n  const codeBlockEndDelimiter = match.groups?.['CodeBlockEndDelimiter'] ?? '';\n  const codeBlockArgs = match.groups?.['CodeBlockArgs'] ?? '';\n  const language = match.groups?.['CodeBlockLanguage'] ?? '';\n\n  const previousText = potentialCodeBlockText.slice(0, match.index);\n  const previousTextLines = previousText.split('\\n');\n\n  return {\n    args: codeBlockArgs,\n    endDelimiter: codeBlockEndDelimiter,\n    language,\n    lineEnd: previousTextLines.length + sourceLines.length,\n    lineStart: previousTextLines.length - 1,\n    prefix: linePrefix,\n    startDelimiter: codeBlockStartDelimiter,\n    text: approximateSectionInfo.text\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  source: 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 === source;\n}\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-dev-utils",
-  "version": "33.1.0",
+  "version": "34.0.0",
   "description": "This is the collection of useful functions that you can use for your Obsidian plugin development",
   "keywords": [
     "obsidian"
@@ -452,15 +452,15 @@
     "@types/doctrine": "^0.0.9",
     "@types/eslint": "^9.6.1",
     "@types/luxon": "^3.7.1",
-    "@types/node": "^24.2.1",
+    "@types/node": "^24.3.0",
     "@types/parsimmon": "^1.10.9",
     "@types/path-browserify": "^1.0.3",
     "@types/picomatch": "^4.0.2",
     "@types/pug": "^2.0.10",
     "@types/react": "^19.1.10",
     "@types/shell-quote": "^1.7.5",
-    "@typescript-eslint/eslint-plugin": "^8.39.1",
-    "@typescript-eslint/parser": "^8.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.40.0",
+    "@typescript-eslint/parser": "^8.40.0",
     "better-typescript-lib": "^2.11.0",
     "commander": "^14.0.0",
     "compare-versions": "^6.1.1",
@@ -475,7 +475,7 @@
     "eslint": "^9.33.0",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.16.1",
-    "eslint-plugin-jsdoc": "^54.0.0",
+    "eslint-plugin-jsdoc": "^54.1.0",
     "eslint-plugin-modules-newlines": "^0.0.7",
     "eslint-plugin-perfectionist": "^4.15.0",
     "eslint-plugin-tsdoc": "^0.4.0",
@@ -486,12 +486,12 @@
     "moment": "^2.30.1",
     "monkey-around": "^3.0.0",
     "npm-run-all": "^4.1.5",
-    "obsidian": "^1.8.7",
-    "obsidian-typings": "^3.16.0",
+    "obsidian": "latest",
+    "obsidian-typings": "obsidian-public-latest",
     "path-browserify": "^1.0.1",
     "postcss": "^8.5.6",
     "postcss-modules": "^6.0.1",
-    "preact": "^10.27.0",
+    "preact": "^10.27.1",
     "react": "^19.1.1",
     "remark": "^15.0.1",
     "remark-parse": "^11.0.0",
@@ -503,7 +503,7 @@
     "tsx": "^4.20.4",
     "type-fest": "^4.41.0",
     "typescript": "^5.9.2",
-    "typescript-eslint": "^8.39.1",
+    "typescript-eslint": "^8.40.0",
     "unist-util-visit": "^5.0.0"
   },
   "overrides": {