@principal-ade/markdown-utils 0.1.3

package/dist/esm/index.js

@@ -0,0 +1,741 @@
+// src/types/chunks.ts
+var CHUNK_TYPES = {
+  MARKDOWN: "markdown_chunk",
+  MERMAID: "mermaid_chunk",
+  SLIDE: "slide_chunk",
+  CODE: "code_chunk"
+};
+var isMarkdownChunk = (chunk) => chunk.type === CHUNK_TYPES.MARKDOWN;
+var isMermaidChunk = (chunk) => chunk.type === CHUNK_TYPES.MERMAID;
+var isCodeChunk = (chunk) => chunk.type === CHUNK_TYPES.CODE;
+// src/types/presentation.ts
+var MarkdownSourceType;
+((MarkdownSourceType2) => {
+  MarkdownSourceType2["WORKSPACE_FILE"] = "workspace_file";
+  MarkdownSourceType2["REMOTE_FILE"] = "remote_file";
+  MarkdownSourceType2["GITHUB_FILE"] = "github_file";
+  MarkdownSourceType2["DRAFT"] = "draft";
+  MarkdownSourceType2["GITHUB_ISSUE"] = "github_issue";
+  MarkdownSourceType2["GITHUB_PULL_REQUEST"] = "github_pull_request";
+  MarkdownSourceType2["GITHUB_GIST"] = "github_gist";
+})(MarkdownSourceType ||= {});
+// src/utils/markdown-parser.ts
+function hashMarkdownString(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function parseMarkdownChunks(markdownContent, idPrefix, customParsers) {
+  try {
+    if (typeof markdownContent !== "string") {
+      throw new Error("Invalid markdown content provided");
+    }
+    if (!markdownContent || markdownContent.trim() === "") {
+      return [];
+    }
+    const chunks = [];
+    const mermaidRegex = /^```mermaid\n([\s\S]*?)\n^```$/gm;
+    let lastIndex = 0;
+    let match;
+    let partCounter = 0;
+    while ((match = mermaidRegex.exec(markdownContent)) !== null) {
+      partCounter++;
+      if (match.index > lastIndex) {
+        const mdContent = markdownContent.substring(lastIndex, match.index);
+        if (mdContent.trim()) {
+          chunks.push({
+            type: CHUNK_TYPES.MARKDOWN,
+            content: mdContent,
+            id: `${idPrefix}-md-${partCounter}-${hashMarkdownString(mdContent)}`
+          });
+        }
+      }
+      partCounter++;
+      const mermaidContent = match[1].trim();
+      chunks.push({
+        type: CHUNK_TYPES.MERMAID,
+        content: mermaidContent,
+        id: `${idPrefix}-mermaid-${partCounter}-${hashMarkdownString(mermaidContent)}`
+      });
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < markdownContent.length) {
+      partCounter++;
+      const remainingMdContent = markdownContent.substring(lastIndex);
+      if (remainingMdContent.trim()) {
+        chunks.push({
+          type: CHUNK_TYPES.MARKDOWN,
+          content: remainingMdContent,
+          id: `${idPrefix}-md-${partCounter}-${hashMarkdownString(remainingMdContent)}`
+        });
+      }
+    }
+    if (chunks.length === 0 && markdownContent.trim()) {
+      chunks.push({
+        type: CHUNK_TYPES.MARKDOWN,
+        content: markdownContent,
+        id: `${idPrefix}-md-only-${hashMarkdownString(markdownContent)}`
+      });
+    }
+    if (customParsers && customParsers.length > 0) {
+      let processedChunks = chunks;
+      for (const parser of customParsers) {
+        const newChunks = [];
+        for (const chunk of processedChunks) {
+          if (chunk.type === CHUNK_TYPES.MARKDOWN) {
+            const parsed = parser(chunk.content, chunk.id);
+            if (parsed.length > 0) {
+              newChunks.push(...parsed);
+            } else {
+              newChunks.push(chunk);
+            }
+          } else {
+            newChunks.push(chunk);
+          }
+        }
+        processedChunks = newChunks;
+      }
+      return processedChunks;
+    }
+    return chunks;
+  } catch (error) {
+    console.error("Error in parseMarkdownChunks:", error);
+    return markdownContent ? [
+      {
+        type: CHUNK_TYPES.MARKDOWN,
+        content: markdownContent,
+        id: `${idPrefix}-md-error-fallback-${hashMarkdownString(markdownContent)}`
+      }
+    ] : [];
+  }
+}
+// src/utils/presentation.ts
+function hashMarkdownString2(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function extractSlideTitle(content) {
+  const lines = content.split(`
+`).filter((line) => line.trim());
+  for (const line of lines) {
+    const headingMatch = line.match(/^#+\s+(.+)$/);
+    if (headingMatch) {
+      return headingMatch[1].trim();
+    }
+  }
+  if (lines.length > 0) {
+    const firstLine = lines[0];
+    return firstLine.length > 50 ? firstLine.substring(0, 47) + "..." : firstLine;
+  }
+  return "Untitled Slide";
+}
+function parseMarkdownIntoPresentationFromSource(source, customParsers) {
+  const presentation = parseMarkdownIntoPresentation(source.content, source.repositoryInfo, customParsers);
+  presentation.source = source;
+  return presentation;
+}
+function parseMarkdownIntoPresentation(markdownContent, repositoryInfo, customParsers) {
+  const hasMultipleHeaders = detectMultipleHeaders(markdownContent);
+  if (!hasMultipleHeaders) {
+    const id = `slide-0-${hashMarkdownString2(markdownContent)}`;
+    const chunks = parseMarkdownChunks(markdownContent, id, customParsers);
+    return {
+      slides: [
+        {
+          id,
+          title: extractSlideTitle(markdownContent),
+          location: {
+            startLine: 0,
+            endLine: markdownContent.split(`
+`).length - 1,
+            content: markdownContent
+          },
+          chunks
+        }
+      ],
+      originalContent: markdownContent,
+      repositoryInfo
+    };
+  }
+  const lines = markdownContent.split(`
+`);
+  const slides = [];
+  let currentSlideLines = [];
+  let currentSlideStartLine = 0;
+  let inCodeBlock = false;
+  let codeBlockDelimiter = "";
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("```") || line.trim().startsWith("~~~")) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeBlockDelimiter = line.trim().substring(0, 3);
+      } else if (line.trim().startsWith(codeBlockDelimiter)) {
+        inCodeBlock = false;
+        codeBlockDelimiter = "";
+      }
+    }
+    const isDelimiter = !inCodeBlock && line.trim().startsWith("#") && !line.trim().startsWith("###");
+    if (isDelimiter && currentSlideLines.length > 0) {
+      const slideContent = currentSlideLines.join(`
+`);
+      const slideId = `slide-${slides.length}-${hashMarkdownString2(slideContent)}`;
+      const chunks = parseMarkdownChunks(slideContent, slideId, customParsers);
+      slides.push({
+        id: slideId,
+        title: extractSlideTitle(slideContent),
+        location: {
+          startLine: currentSlideStartLine,
+          endLine: i - 1,
+          content: slideContent
+        },
+        chunks
+      });
+      currentSlideLines = [line];
+      currentSlideStartLine = i;
+    } else {
+      currentSlideLines.push(line);
+    }
+  }
+  if (currentSlideLines.length > 0) {
+    const slideContent = currentSlideLines.join(`
+`);
+    const slideId = `slide-${slides.length}-${hashMarkdownString2(slideContent)}`;
+    const chunks = parseMarkdownChunks(slideContent, slideId, customParsers);
+    slides.push({
+      id: slideId,
+      title: extractSlideTitle(slideContent),
+      location: {
+        startLine: currentSlideStartLine,
+        endLine: lines.length - 1,
+        content: slideContent
+      },
+      chunks
+    });
+  }
+  return {
+    slides,
+    originalContent: markdownContent,
+    repositoryInfo
+  };
+}
+function detectMultipleHeaders(markdownContent) {
+  const lines = markdownContent.split(`
+`);
+  let h1Count = 0;
+  let h2Count = 0;
+  let inCodeBlock = false;
+  let codeBlockDelimiter = "";
+  for (const line of lines) {
+    if (line.trim().startsWith("```") || line.trim().startsWith("~~~")) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeBlockDelimiter = line.trim().substring(0, 3);
+      } else if (line.trim().startsWith(codeBlockDelimiter)) {
+        inCodeBlock = false;
+        codeBlockDelimiter = "";
+      }
+    }
+    if (!inCodeBlock) {
+      if (line.trim().startsWith("#") && !line.trim().startsWith("###")) {
+        if (!line.trim().startsWith("##")) {
+          h1Count++;
+        } else {
+          h2Count++;
+        }
+      }
+    }
+  }
+  const totalHeaders = h1Count + h2Count;
+  return totalHeaders > 1;
+}
+function serializePresentationToMarkdown(presentation) {
+  return presentation.slides.map((slide) => slide.location.content).join(`
+`);
+}
+function updatePresentationSlide(presentation, slideIndex, newContent, customParsers) {
+  if (slideIndex < 0 || slideIndex >= presentation.slides.length) {
+    throw new Error("Invalid slide index");
+  }
+  const updatedSlides = [...presentation.slides];
+  const slide = updatedSlides[slideIndex];
+  const newChunks = parseMarkdownChunks(newContent, slide.id, customParsers);
+  updatedSlides[slideIndex] = {
+    ...slide,
+    location: {
+      ...slide.location,
+      content: newContent
+    },
+    chunks: newChunks,
+    title: extractSlideTitle(newContent)
+  };
+  return {
+    ...presentation,
+    slides: updatedSlides,
+    originalContent: serializePresentationToMarkdown({ ...presentation, slides: updatedSlides })
+  };
+}
+// src/utils/bash-parser.ts
+function parseBashCommands(codeString) {
+  const lines = codeString.split(`
+`);
+  const commands = [];
+  let currentCommand = "";
+  let commandStartLine = 0;
+  let currentDescription = "";
+  let inBackslashContinuation = false;
+  for (let i = 0;i < lines.length; i++) {
+    const rawLine = lines[i];
+    const line = rawLine.trim();
+    if (!line) {
+      if (currentCommand && !inBackslashContinuation) {
+        commands.push({
+          command: currentCommand.trim(),
+          description: currentDescription || undefined,
+          line: commandStartLine + 1
+        });
+        currentCommand = "";
+        currentDescription = "";
+      }
+      continue;
+    }
+    if (line.startsWith("#")) {
+      if (!currentCommand) {
+        currentDescription = line.substring(1).trim();
+      }
+      continue;
+    }
+    const endsWithBackslash = rawLine.trimEnd().endsWith("\\");
+    if (endsWithBackslash || inBackslashContinuation) {
+      if (!currentCommand) {
+        commandStartLine = i;
+      }
+      if (endsWithBackslash) {
+        const content = rawLine.trimEnd().slice(0, -1).trim();
+        currentCommand += (currentCommand ? " " : "") + content;
+        inBackslashContinuation = true;
+      } else {
+        currentCommand += (currentCommand ? " " : "") + line;
+        inBackslashContinuation = false;
+      }
+      continue;
+    }
+    const isPipeContinuation = line.startsWith("|") || line.startsWith("&&") || line.startsWith("||");
+    const previousLineEndsWithOperator = currentCommand && (currentCommand.trim().endsWith("|") || currentCommand.trim().endsWith("&&") || currentCommand.trim().endsWith("||") || currentCommand.trim().endsWith(";"));
+    if (currentCommand && (isPipeContinuation || previousLineEndsWithOperator)) {
+      currentCommand += (currentCommand.endsWith(" ") ? "" : " ") + line;
+      continue;
+    }
+    if (currentCommand) {
+      commands.push({
+        command: currentCommand.trim(),
+        description: currentDescription || undefined,
+        line: commandStartLine + 1
+      });
+      currentDescription = "";
+    }
+    commandStartLine = i;
+    currentCommand = line;
+  }
+  if (currentCommand) {
+    commands.push({
+      command: currentCommand.trim(),
+      description: currentDescription || undefined,
+      line: commandStartLine + 1
+    });
+  }
+  return commands.filter((cmd) => cmd.command.length > 0);
+}
+function getCommandDisplayName(command, maxLength = 50) {
+  if (command.description) {
+    return command.description.length <= maxLength ? command.description : command.description.substring(0, maxLength - 3) + "...";
+  }
+  const cmdText = command.command;
+  if (cmdText.length <= maxLength) {
+    return cmdText;
+  }
+  return cmdText.substring(0, maxLength - 3) + "...";
+}
+// src/utils/image-urls.ts
+function isRelativeUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return false;
+  }
+  if (url.startsWith("//")) {
+    return false;
+  }
+  if (url.startsWith("data:")) {
+    return false;
+  }
+  if (url.startsWith("blob:")) {
+    return false;
+  }
+  return true;
+}
+function transformImageUrl(src, repositoryInfo) {
+  if (!repositoryInfo || !isRelativeUrl(src)) {
+    return src;
+  }
+  const { owner, repo, branch = "main", basePath = "" } = repositoryInfo;
+  let fullPath;
+  if (src.startsWith("/")) {
+    fullPath = src.substring(1);
+  } else {
+    let cleanPath = src;
+    if (cleanPath.startsWith("./")) {
+      cleanPath = cleanPath.substring(2);
+    }
+    if (cleanPath.startsWith("../")) {
+      console.warn("Relative parent directory navigation in image URLs is not fully supported:", src);
+      cleanPath = cleanPath.replace(/^(\.\.\/)+/, "");
+    }
+    if (basePath) {
+      const cleanBasePath = basePath.replace(/^\/+|\/+$/g, "");
+      fullPath = `${cleanBasePath}/${cleanPath}`;
+    } else {
+      fullPath = cleanPath;
+    }
+  }
+  const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${fullPath}`;
+  return rawUrl;
+}
+function transformMarkdownImageUrls(markdownContent, repositoryInfo) {
+  if (!repositoryInfo) {
+    return markdownContent;
+  }
+  const transformedContent = markdownContent.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_, altText, imagePath) => {
+    const transformedPath = transformImageUrl(imagePath, repositoryInfo);
+    return `![${altText}](${transformedPath})`;
+  });
+  return transformedContent;
+}
+// src/utils/slide-titles.ts
+function extractSlideTitle2(content, slideIndex) {
+  const lines = content.split(`
+`);
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith("#")) {
+      const match = trimmedLine.match(/^#{1,2}\s+(.+)$/);
+      if (match && match[1]) {
+        return match[1].replace(/\*\*/g, "").replace(/\*/g, "").replace(/`/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim();
+      }
+    }
+  }
+  return `Slide ${slideIndex + 1}`;
+}
+function extractAllSlideTitles(slides) {
+  return slides.map((slide, index) => extractSlideTitle2(slide, index));
+}
+function getAllSlideTitles(slides) {
+  return slides.map((slide) => slide.title);
+}
+function findSlideByTitle(slides, title) {
+  return slides.find((slide) => slide.title === title);
+}
+function findSlideIndexByTitle(slides, title) {
+  return slides.findIndex((slide) => slide.title === title);
+}
+// src/diff/textDiff.ts
+function diffText(beforeContent, afterContent) {
+  if (beforeContent === "" && afterContent === "") {
+    return [];
+  }
+  const beforeLines = beforeContent === "" ? [] : beforeContent.split(`
+`);
+  const afterLines = afterContent === "" ? [] : afterContent.split(`
+`);
+  const lcs = longestCommonSubsequence(beforeLines, afterLines);
+  return buildDiffFromLCS(beforeLines, afterLines, lcs);
+}
+function longestCommonSubsequence(beforeLines, afterLines) {
+  const m = beforeLines.length;
+  const n = afterLines.length;
+  const lcs = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
+  for (let i = 1;i <= m; i++) {
+    for (let j = 1;j <= n; j++) {
+      if (beforeLines[i - 1] === afterLines[j - 1]) {
+        lcs[i][j] = lcs[i - 1][j - 1] + 1;
+      } else {
+        lcs[i][j] = Math.max(lcs[i - 1][j], lcs[i][j - 1]);
+      }
+    }
+  }
+  return lcs;
+}
+function buildDiffFromLCS(beforeLines, afterLines, lcs) {
+  const result = [];
+  let i = beforeLines.length;
+  let j = afterLines.length;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && beforeLines[i - 1] === afterLines[j - 1]) {
+      result.unshift({
+        type: "unchanged",
+        value: beforeLines[i - 1]
+      });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+      result.unshift({
+        type: "add",
+        value: afterLines[j - 1]
+      });
+      j--;
+    } else if (i > 0 && (j === 0 || lcs[i][j - 1] < lcs[i - 1][j])) {
+      result.unshift({
+        type: "remove",
+        value: beforeLines[i - 1]
+      });
+      i--;
+    }
+  }
+  return result.map((diff, index) => ({
+    ...diff,
+    lineNumber: index + 1
+  }));
+}
+function normalizedTextEquals(text1, text2) {
+  return normalizeText(text1) === normalizeText(text2);
+}
+function normalizeText(text) {
+  return text.replace(/\r\n/g, `
+`).split(`
+`).map((line) => line.trimEnd()).join(`
+`).trim();
+}
+
+// src/diff/matchSlides.ts
+function matchSlides(beforeSlides, afterSlides) {
+  const matches = [];
+  const matchedBeforeIndices = new Set;
+  const matchedAfterIndices = new Set;
+  for (let beforeIndex = 0;beforeIndex < beforeSlides.length; beforeIndex++) {
+    const beforeSlide = beforeSlides[beforeIndex];
+    for (let afterIndex = 0;afterIndex < afterSlides.length; afterIndex++) {
+      if (matchedAfterIndices.has(afterIndex)) {
+        continue;
+      }
+      const afterSlide = afterSlides[afterIndex];
+      if (normalizeTitleForMatching(beforeSlide.title) === normalizeTitleForMatching(afterSlide.title)) {
+        matches.push({
+          beforeSlide,
+          afterSlide,
+          beforeIndex,
+          afterIndex,
+          matchedBy: "title"
+        });
+        matchedBeforeIndices.add(beforeIndex);
+        matchedAfterIndices.add(afterIndex);
+        break;
+      }
+    }
+  }
+  const unmatchedBeforeIndices = beforeSlides.map((_, i) => i).filter((i) => !matchedBeforeIndices.has(i));
+  const unmatchedAfterIndices = afterSlides.map((_, i) => i).filter((i) => !matchedAfterIndices.has(i));
+  const minUnmatched = Math.min(unmatchedBeforeIndices.length, unmatchedAfterIndices.length);
+  for (let i = 0;i < minUnmatched; i++) {
+    const beforeIndex = unmatchedBeforeIndices[i];
+    const afterIndex = unmatchedAfterIndices[i];
+    matches.push({
+      beforeSlide: beforeSlides[beforeIndex],
+      afterSlide: afterSlides[afterIndex],
+      beforeIndex,
+      afterIndex,
+      matchedBy: "position"
+    });
+    matchedBeforeIndices.add(beforeIndex);
+    matchedAfterIndices.add(afterIndex);
+  }
+  for (let beforeIndex = 0;beforeIndex < beforeSlides.length; beforeIndex++) {
+    if (!matchedBeforeIndices.has(beforeIndex)) {
+      matches.push({
+        beforeSlide: beforeSlides[beforeIndex],
+        beforeIndex,
+        matchedBy: "none"
+      });
+    }
+  }
+  for (let afterIndex = 0;afterIndex < afterSlides.length; afterIndex++) {
+    if (!matchedAfterIndices.has(afterIndex)) {
+      matches.push({
+        afterSlide: afterSlides[afterIndex],
+        afterIndex,
+        matchedBy: "none"
+      });
+    }
+  }
+  matches.sort((a, b) => {
+    const aIndex = a.beforeIndex ?? a.afterIndex ?? 0;
+    const bIndex = b.beforeIndex ?? b.afterIndex ?? 0;
+    return aIndex - bIndex;
+  });
+  return matches;
+}
+function slidesAreEqual(slide1, slide2) {
+  return normalizeSlideContent(slide1) === normalizeSlideContent(slide2);
+}
+function normalizeSlideContent(slide) {
+  return normalizeText(slide.location.content);
+}
+function normalizeTitleForMatching(title) {
+  return title.trim().replace(/\s+/g, " ").toLowerCase();
+}
+
+// src/diff/diffSummary.ts
+function calculateDiffSummary(diff) {
+  const summary = {
+    totalSlidesBefore: diff.before.slides.length,
+    totalSlidesAfter: diff.after.slides.length,
+    added: 0,
+    removed: 0,
+    modified: 0,
+    unchanged: 0,
+    moved: 0
+  };
+  for (const slideDiff of diff.slideDiffs) {
+    switch (slideDiff.status) {
+      case "added":
+        summary.added++;
+        break;
+      case "removed":
+        summary.removed++;
+        break;
+      case "modified":
+        summary.modified++;
+        break;
+      case "unchanged":
+        summary.unchanged++;
+        break;
+      case "moved":
+        summary.moved++;
+        break;
+    }
+  }
+  return summary;
+}
+function hasChanges(diff) {
+  const { summary } = diff;
+  return summary.added > 0 || summary.removed > 0 || summary.modified > 0 || summary.moved > 0;
+}
+function getTotalChangedSlides(summary) {
+  return summary.added + summary.removed + summary.modified + summary.moved;
+}
+function formatDiffSummary(summary) {
+  const parts = [];
+  if (summary.added > 0) {
+    parts.push(`${summary.added} added`);
+  }
+  if (summary.removed > 0) {
+    parts.push(`${summary.removed} removed`);
+  }
+  if (summary.modified > 0) {
+    parts.push(`${summary.modified} modified`);
+  }
+  if (summary.moved > 0) {
+    parts.push(`${summary.moved} moved`);
+  }
+  if (parts.length === 0) {
+    return "No changes";
+  }
+  return parts.join(", ");
+}
+
+// src/diff/diffPresentations.ts
+function diffPresentations(before, after) {
+  const matches = matchSlides(before.slides, after.slides);
+  const slideDiffs = matches.map((match) => createSlideDiff(match));
+  const presentationDiff = {
+    before,
+    after,
+    slideDiffs,
+    summary: {
+      totalSlidesBefore: 0,
+      totalSlidesAfter: 0,
+      added: 0,
+      removed: 0,
+      modified: 0,
+      unchanged: 0,
+      moved: 0
+    }
+  };
+  presentationDiff.summary = calculateDiffSummary(presentationDiff);
+  return presentationDiff;
+}
+function createSlideDiff(match) {
+  const { beforeSlide, afterSlide, beforeIndex, afterIndex, matchedBy } = match;
+  let status;
+  let contentChanges;
+  let titleChanged = false;
+  if (!beforeSlide && afterSlide) {
+    status = "added";
+  } else if (beforeSlide && !afterSlide) {
+    status = "removed";
+  } else if (beforeSlide && afterSlide) {
+    const contentEqual = slidesAreEqual(beforeSlide, afterSlide);
+    const positionChanged = beforeIndex !== afterIndex;
+    titleChanged = beforeSlide.title !== afterSlide.title;
+    if (contentEqual) {
+      if (positionChanged) {
+        status = "moved";
+      } else {
+        status = "unchanged";
+      }
+    } else {
+      status = "modified";
+      contentChanges = diffText(beforeSlide.location.content, afterSlide.location.content);
+    }
+  } else {
+    status = "unchanged";
+  }
+  return {
+    status,
+    beforeSlide,
+    afterSlide,
+    beforeIndex,
+    afterIndex,
+    contentChanges,
+    titleChanged
+  };
+}
+export {
+  updatePresentationSlide,
+  transformMarkdownImageUrls,
+  transformImageUrl,
+  slidesAreEqual,
+  serializePresentationToMarkdown,
+  parseMarkdownIntoPresentationFromSource,
+  parseMarkdownIntoPresentation,
+  parseMarkdownChunks,
+  parseBashCommands,
+  normalizedTextEquals,
+  normalizeText,
+  normalizeSlideContent,
+  matchSlides,
+  isRelativeUrl,
+  isMermaidChunk,
+  isMarkdownChunk,
+  isCodeChunk,
+  hasChanges,
+  getTotalChangedSlides,
+  getCommandDisplayName,
+  getAllSlideTitles,
+  formatDiffSummary,
+  findSlideIndexByTitle,
+  findSlideByTitle,
+  extractSlideTitle,
+  extractAllSlideTitles,
+  diffText,
+  diffPresentations,
+  calculateDiffSummary,
+  MarkdownSourceType,
+  CHUNK_TYPES
+};