@lostgradient/cinder 0.5.0 → 0.7.0

package/dist/server/index.server-ezpdsg81.js

@@ -0,0 +1,733 @@
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/source-diff-viewer/source-diff-viewer.svelte
+import * as $ from "svelte/internal/server";
+
+// src/components/source-diff-viewer/source-diff-viewer.utilities.ts
+var DEFAULT_MAX_LINES = 1000;
+var HUNK_HEADER_PATTERN = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+var TEXT_ENCODER = new TextEncoder;
+function stripSyntheticDiffPrefix(path) {
+  return path.replace(/^[ab]\//, "");
+}
+function stripLeadingPathSegmentPrefix(path) {
+  return path.replace(/^[^/]+\//, "");
+}
+function sharedPathSegmentSuffixSegments(firstPath, secondPath) {
+  const firstSegments = firstPath.split("/");
+  const secondSegments = secondPath.split("/");
+  const sharedSegments = [];
+  while (firstSegments.length > 0 && secondSegments.length > 0) {
+    const firstSegment = firstSegments.pop();
+    const secondSegment = secondSegments.pop();
+    if (firstSegment !== secondSegment || firstSegment === undefined)
+      break;
+    sharedSegments.unshift(firstSegment);
+  }
+  return sharedSegments;
+}
+function sharedPathSegmentSuffix(firstPath, secondPath) {
+  const sharedSegments = sharedPathSegmentSuffixSegments(firstPath, secondPath);
+  return sharedSegments.length > 0 ? sharedSegments.join("/") : null;
+}
+function decodeGitQuotedPath(path) {
+  if (!path.startsWith('"') || !path.endsWith('"'))
+    return path;
+  const bytes = [];
+  const quoted = path.slice(1, -1);
+  for (let index = 0;index < quoted.length; index += 1) {
+    const character = quoted[index];
+    if (character !== "\\") {
+      const codePoint = quoted.codePointAt(index);
+      if (codePoint !== undefined) {
+        bytes.push(...TEXT_ENCODER.encode(String.fromCodePoint(codePoint)));
+        if (codePoint > 65535)
+          index += 1;
+      }
+      continue;
+    }
+    const next = quoted[index + 1];
+    if (next && /[0-7]/.test(next)) {
+      const octal = quoted.slice(index + 1).match(/^[0-7]{1,3}/)?.[0] ?? "";
+      bytes.push(Number.parseInt(octal, 8));
+      index += octal.length;
+      continue;
+    }
+    const escapes = {
+      '"': 34,
+      "\\": 92,
+      a: 7,
+      b: 8,
+      f: 12,
+      n: 10,
+      r: 13,
+      t: 9,
+      v: 11
+    };
+    bytes.push(next ? escapes[next] ?? next.charCodeAt(0) : 92);
+    if (next)
+      index += 1;
+  }
+  return new TextDecoder().decode(new Uint8Array(bytes));
+}
+function parsePatchPath(path, options) {
+  const [pathWithoutTimestamp = path] = path.split("\t");
+  const trimmedPath = decodeGitQuotedPath(pathWithoutTimestamp);
+  const normalized = options.stripSyntheticPrefix ? stripSyntheticDiffPrefix(trimmedPath) : trimmedPath;
+  return normalized === "/dev/null" ? null : normalized;
+}
+function normalizeGitHeaderPaths(oldPath, newPath) {
+  if (!oldPath || !newPath)
+    return { oldPath, newPath };
+  if (oldPath === newPath)
+    return { oldPath, newPath };
+  const oldSegments = oldPath.split("/");
+  const newSegments = newPath.split("/");
+  const sharedSegments = sharedPathSegmentSuffixSegments(oldPath, newPath);
+  const [oldPrefix] = oldSegments;
+  const [newPrefix] = newSegments;
+  if (oldPrefix === "a" && newPrefix === "b") {
+    return {
+      oldPath: stripSyntheticDiffPrefix(oldPath),
+      newPath: stripSyntheticDiffPrefix(newPath)
+    };
+  }
+  if (oldPrefix === "old" && newPrefix === "new") {
+    if (sharedSegments.length >= 2 && oldSegments.length === sharedSegments.length + 1 && newSegments.length === sharedSegments.length + 1) {
+      const sharedSuffix = sharedPathSegmentSuffix(oldPath, newPath);
+      return { oldPath: sharedSuffix, newPath: sharedSuffix };
+    }
+    return {
+      oldPath: stripLeadingPathSegmentPrefix(oldPath),
+      newPath: stripLeadingPathSegmentPrefix(newPath)
+    };
+  }
+  return { oldPath, newPath };
+}
+function readQuotedGitToken(payload, startIndex) {
+  if (payload[startIndex] !== '"')
+    return null;
+  for (let index = startIndex + 1;index < payload.length; index += 1) {
+    if (payload[index] === "\\") {
+      index += 1;
+      continue;
+    }
+    if (payload[index] === '"') {
+      return {
+        token: payload.slice(startIndex, index + 1),
+        endIndex: index + 1
+      };
+    }
+  }
+  return null;
+}
+function parseQuotedDiffGitHeader(payload) {
+  const oldToken = readQuotedGitToken(payload, 0);
+  if (!oldToken)
+    return null;
+  const separator = payload.slice(oldToken.endIndex).match(/^ +/);
+  if (!separator)
+    return null;
+  const newToken = readQuotedGitToken(payload, oldToken.endIndex + separator[0].length);
+  if (!newToken || newToken.endIndex !== payload.length)
+    return null;
+  return normalizeGitHeaderPaths(parsePatchPath(oldToken.token, { stripSyntheticPrefix: false }), parsePatchPath(newToken.token, { stripSyntheticPrefix: false }));
+}
+function parseDiffGitHeader(line) {
+  const payload = line.slice("diff --git ".length);
+  const quotedHeader = parseQuotedDiffGitHeader(payload);
+  if (quotedHeader)
+    return { ...quotedHeader, header: line };
+  const separatorIndexes = [...payload.matchAll(/ /g)].map((match) => match.index ?? -1);
+  for (const separatorIndex2 of separatorIndexes) {
+    if (separatorIndex2 <= 0)
+      continue;
+    const parsedPaths = normalizeGitHeaderPaths(parsePatchPath(payload.slice(0, separatorIndex2), { stripSyntheticPrefix: false }), parsePatchPath(payload.slice(separatorIndex2 + 1), { stripSyntheticPrefix: false }));
+    if (parsedPaths.oldPath && parsedPaths.oldPath === parsedPaths.newPath) {
+      return { ...parsedPaths, header: line };
+    }
+  }
+  const separatorIndex = separatorIndexes[separatorIndexes.length - 1] ?? -1;
+  if (separatorIndex <= 0)
+    return { oldPath: null, newPath: null, header: line };
+  return {
+    ...normalizeGitHeaderPaths(parsePatchPath(payload.slice(0, separatorIndex), { stripSyntheticPrefix: false }), parsePatchPath(payload.slice(separatorIndex + 1), { stripSyntheticPrefix: false })),
+    header: line
+  };
+}
+function createFile(header = null) {
+  return {
+    oldPath: null,
+    newPath: null,
+    header,
+    metadata: [],
+    hunks: []
+  };
+}
+function startFile(files, header = null) {
+  const file = createFile(header);
+  files.push(file);
+  return file;
+}
+function ensureFile(files, header = null) {
+  return files[files.length - 1] ?? startFile(files, header);
+}
+function ensureFileForOldHeader(files) {
+  const current = files[files.length - 1];
+  if (current && current.hunks.length === 0 && (current.header?.startsWith("diff --git ") || current.oldPath === null && current.newPath === null)) {
+    return current;
+  }
+  return startFile(files);
+}
+function hunkHasRenderedContent(hunk) {
+  return hunk.lines.length > 0;
+}
+function fileHasRenderedContent(file) {
+  return file.header !== null && isStandaloneRecursiveDiffMetadata(file.header) || file.metadata.length > 0 || file.hunks.some(hunkHasRenderedContent);
+}
+function hunkIsComplete(hunk, cursor) {
+  if (hunk.oldStart === null || hunk.oldCount === null || hunk.newStart === null || hunk.newCount === null || cursor.oldLineNumber === null || cursor.newLineNumber === null) {
+    return false;
+  }
+  return cursor.oldLineNumber >= hunk.oldStart + hunk.oldCount && cursor.newLineNumber >= hunk.newStart + hunk.newCount;
+}
+function hunkCanReadAfterZeroCountComplete(hunk, rawLine) {
+  return hunk.oldCount === 0 && hunk.newCount === 0 && readRawHunkLine(rawLine, {
+    oldLineNumber: null,
+    newLineNumber: null
+  }) !== null;
+}
+function readRawHunkLine(rawLine, cursor) {
+  if (rawLine.startsWith("\\ ")) {
+    return {
+      kind: "metadata",
+      content: rawLine.slice(2),
+      oldLineNumber: null,
+      newLineNumber: null,
+      metadataPrefix: "\\"
+    };
+  }
+  const prefix = rawLine[0];
+  const content = rawLine.slice(1);
+  const kind = prefix === "+" ? "addition" : prefix === "-" ? "removal" : prefix === " " ? "context" : null;
+  if (!kind)
+    return null;
+  return readLine(kind, content, cursor);
+}
+function createHunkMetadataLine(rawLine, metadataPrefix) {
+  const line = {
+    kind: "metadata",
+    content: rawLine,
+    oldLineNumber: null,
+    newLineNumber: null
+  };
+  if (metadataPrefix)
+    line.metadataPrefix = metadataPrefix;
+  return line;
+}
+function parseBinaryNoticePaths(file, rawLine) {
+  const payload = rawLine.match(/^Binary files (.+) differ$/)?.[1];
+  if (!payload)
+    return null;
+  const candidates = [];
+  let delimiterIndex = payload.indexOf(" and ");
+  while (delimiterIndex !== -1) {
+    const rawOldPath = payload.slice(0, delimiterIndex);
+    const rawNewPath = payload.slice(delimiterIndex + " and ".length);
+    const oldPath = parsePatchPath(rawOldPath, {
+      stripSyntheticPrefix: true
+    });
+    const newPath = parsePatchPath(rawNewPath, {
+      stripSyntheticPrefix: true
+    });
+    const normalizedPaths = normalizeGitHeaderPaths(oldPath, newPath);
+    const normalizedOldPath = normalizedPaths.oldPath !== null && file.oldPath !== null && normalizedPaths.oldPath.endsWith(`/${file.oldPath}`) ? file.oldPath : normalizedPaths.oldPath;
+    const normalizedNewPath = normalizedPaths.newPath !== null && file.newPath !== null && normalizedPaths.newPath.endsWith(`/${file.newPath}`) ? file.newPath : normalizedPaths.newPath;
+    candidates.push({
+      oldPath: normalizedOldPath,
+      newPath: normalizedNewPath,
+      hasKnownEndpoints: (rawOldPath.startsWith("a/") || rawOldPath === "/dev/null") && (rawNewPath.startsWith("b/") || rawNewPath === "/dev/null")
+    });
+    delimiterIndex = payload.indexOf(" and ", delimiterIndex + 1);
+  }
+  const preferredCandidates = candidates.some((candidate) => candidate.hasKnownEndpoints) ? candidates.filter((candidate) => candidate.hasKnownEndpoints) : candidates;
+  if (preferredCandidates.length === 1)
+    return preferredCandidates[0] ?? null;
+  return preferredCandidates.find((candidate) => candidate.oldPath === file.oldPath && candidate.newPath === file.newPath) ?? null;
+}
+function applyFileMetadata(file, rawLine) {
+  const binaryPaths = parseBinaryNoticePaths(file, rawLine);
+  if (binaryPaths) {
+    file.oldPath = binaryPaths.oldPath;
+    file.newPath = binaryPaths.newPath;
+    return;
+  }
+  if (rawLine.startsWith("new file mode ")) {
+    file.oldPath = null;
+    return;
+  }
+  if (rawLine.startsWith("deleted file mode ")) {
+    file.newPath = null;
+    return;
+  }
+  if (rawLine.startsWith("rename from ")) {
+    file.oldPath = parsePatchPath(rawLine.slice("rename from ".length), {
+      stripSyntheticPrefix: false
+    });
+    return;
+  }
+  if (rawLine.startsWith("rename to ")) {
+    file.newPath = parsePatchPath(rawLine.slice("rename to ".length), {
+      stripSyntheticPrefix: false
+    });
+    return;
+  }
+  if (rawLine.startsWith("copy from ")) {
+    file.oldPath = parsePatchPath(rawLine.slice("copy from ".length), {
+      stripSyntheticPrefix: false
+    });
+    return;
+  }
+  if (rawLine.startsWith("copy to ")) {
+    file.newPath = parsePatchPath(rawLine.slice("copy to ".length), {
+      stripSyntheticPrefix: false
+    });
+  }
+}
+function pushMetadata(files, rawLine, renderedLineCount, maxLines) {
+  applyFileMetadata(ensureFile(files), rawLine);
+  if (renderedLineCount < maxLines) {
+    ensureFile(files).metadata.push(rawLine);
+    return { renderedLineCount: renderedLineCount + 1, lineWasRendered: true };
+  }
+  return { renderedLineCount, lineWasRendered: false };
+}
+function preparePatchLines(patch) {
+  const lines = patch.split(`
+`);
+  while (lines[lines.length - 1] === "")
+    lines.pop();
+  return lines;
+}
+function stripLineTerminatorCarriageReturn(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function pruneFiles(files) {
+  return files.map((file) => ({
+    ...file,
+    hunks: file.hunks.filter(hunkHasRenderedContent)
+  })).filter(fileHasRenderedContent);
+}
+function readHunkLine(hunk, cursor, rawLine, renderedLineCount, maxLines, previousHunkDiffLineWasRendered) {
+  const line = readRawHunkLine(rawLine, cursor);
+  if (!line) {
+    const shouldPreserveMetadata = previousHunkDiffLineWasRendered || hunk.lines.length === 0;
+    if (shouldPreserveMetadata && renderedLineCount < maxLines) {
+      hunk.lines.push(createHunkMetadataLine(rawLine));
+      return {
+        renderedLineCount: renderedLineCount + 1,
+        lineWasRead: true,
+        lineWasRendered: true
+      };
+    }
+    return {
+      renderedLineCount,
+      lineWasRead: true,
+      lineWasRendered: false
+    };
+  }
+  if (line.kind === "metadata") {
+    const shouldPreserveMetadata = previousHunkDiffLineWasRendered || hunk.lines.length === 0;
+    if (shouldPreserveMetadata && renderedLineCount < maxLines) {
+      hunk.lines.push(line);
+      return {
+        renderedLineCount: renderedLineCount + 1,
+        lineWasRead: true,
+        lineWasRendered: true
+      };
+    }
+    return {
+      renderedLineCount,
+      lineWasRead: true,
+      lineWasRendered: false
+    };
+  }
+  if (renderedLineCount < maxLines) {
+    hunk.lines.push(line);
+    return { renderedLineCount: renderedLineCount + 1, lineWasRead: true, lineWasRendered: true };
+  }
+  return { renderedLineCount, lineWasRead: true, lineWasRendered: false };
+}
+function createParsedGitFile(rawLine) {
+  return {
+    ...parseDiffGitHeader(rawLine),
+    metadata: [],
+    hunks: []
+  };
+}
+function parseGitFileSidePath(file, rawPath, currentPath) {
+  const parsedPath = parsePatchPath(rawPath, { stripSyntheticPrefix: false });
+  if (!parsedPath || !file.header?.startsWith("diff --git "))
+    return parsedPath;
+  if (currentPath && parsedPath === currentPath)
+    return currentPath;
+  const [prefix] = parsedPath.split("/");
+  const hasKnownDiffPrefix = prefix === "a" || prefix === "b" || prefix === "old" || prefix === "new";
+  if (prefix === "a" || prefix === "b")
+    return stripSyntheticDiffPrefix(parsedPath);
+  if (currentPath && hasKnownDiffPrefix && parsedPath.endsWith(`/${currentPath}`)) {
+    return currentPath;
+  }
+  const pathWithoutPrefix = stripLeadingPathSegmentPrefix(parsedPath);
+  return currentPath && hasKnownDiffPrefix && pathWithoutPrefix === currentPath ? currentPath : parsedPath;
+}
+function createEmptyParseResult() {
+  return {
+    files: [],
+    totalLineCount: 0,
+    renderedLineCount: 0,
+    truncated: false
+  };
+}
+function createHunk(header) {
+  const match = HUNK_HEADER_PATTERN.exec(header);
+  const oldStart = parseHunkNumber(match?.[1]);
+  const oldCount = match?.[2] === undefined ? oldStart === null ? null : 1 : Number(match[2]);
+  const newStart = parseHunkNumber(match?.[3]);
+  const newCount = match?.[4] === undefined ? newStart === null ? null : 1 : Number(match[4]);
+  return {
+    hunk: {
+      header,
+      oldStart,
+      oldCount,
+      newStart,
+      newCount,
+      lines: []
+    },
+    cursor: {
+      oldLineNumber: oldStart,
+      newLineNumber: newStart
+    }
+  };
+}
+function parseHunkNumber(value) {
+  return value === undefined ? null : Number(value);
+}
+function isStandaloneRecursiveDiffMetadata(rawLine) {
+  return rawLine.startsWith("Only in ") || rawLine.startsWith("Common subdirectories: ") || rawLine.startsWith("Binary files ") || rawLine.startsWith("Symbolic links ") && rawLine.endsWith(" differ") || rawLine.startsWith("File ") && rawLine.includes(" is a ") && rawLine.includes(" while file ");
+}
+function isGitBinaryNoticeMetadata(file, rawLine) {
+  if (/^Binary files (?:a\/|\/dev\/null).+ and (?:b\/|\/dev\/null).+ differ$/.test(rawLine)) {
+    return true;
+  }
+  const binaryPaths = parseBinaryNoticePaths(file, rawLine);
+  return binaryPaths?.oldPath === file.oldPath && binaryPaths.newPath === file.newPath;
+}
+function isIndexedUnifiedFilePrelude(line, nextLine, nextNextLine, nextNextNextLine, nextNextNextNextLine) {
+  return line.startsWith("Index: ") && nextLine !== undefined && /^={3,}$/.test(nextLine) && nextNextLine?.startsWith("--- ") === true && nextNextNextLine?.startsWith("+++ ") === true && nextNextNextNextLine?.startsWith("@@ ") === true;
+}
+function readLine(kind, content, cursor) {
+  if (kind === "addition") {
+    const line2 = {
+      kind,
+      content,
+      oldLineNumber: null,
+      newLineNumber: cursor.newLineNumber
+    };
+    if (cursor.newLineNumber !== null)
+      cursor.newLineNumber += 1;
+    return line2;
+  }
+  if (kind === "removal") {
+    const line2 = {
+      kind,
+      content,
+      oldLineNumber: cursor.oldLineNumber,
+      newLineNumber: null
+    };
+    if (cursor.oldLineNumber !== null)
+      cursor.oldLineNumber += 1;
+    return line2;
+  }
+  const line = {
+    kind,
+    content,
+    oldLineNumber: cursor.oldLineNumber,
+    newLineNumber: cursor.newLineNumber
+  };
+  if (cursor.oldLineNumber !== null)
+    cursor.oldLineNumber += 1;
+  if (cursor.newLineNumber !== null)
+    cursor.newLineNumber += 1;
+  return line;
+}
+function positiveInteger(value) {
+  if (value === undefined || !Number.isFinite(value))
+    return DEFAULT_MAX_LINES;
+  return Math.max(0, Math.floor(value));
+}
+function getSourceDiffFileLabel(file) {
+  if (file.newPath && file.oldPath && file.newPath !== file.oldPath) {
+    return `${file.oldPath} -> ${file.newPath}`;
+  }
+  return file.newPath ?? file.oldPath ?? file.header ?? "Patch";
+}
+function getSourceDiffLineLabel(line) {
+  if (line.kind === "addition") {
+    return `Added line ${line.newLineNumber ?? "unknown"}: ${line.content}`;
+  }
+  if (line.kind === "removal") {
+    return `Removed line ${line.oldLineNumber ?? "unknown"}: ${line.content}`;
+  }
+  if (line.kind === "metadata") {
+    return `Diff metadata: ${line.content}`;
+  }
+  if (line.oldLineNumber !== null && line.newLineNumber !== null && line.oldLineNumber !== line.newLineNumber) {
+    return `Context old line ${line.oldLineNumber}, new line ${line.newLineNumber}: ${line.content}`;
+  }
+  const lineNumber = line.newLineNumber ?? line.oldLineNumber ?? "unknown";
+  return `Context line ${lineNumber}: ${line.content}`;
+}
+function parseUnifiedPatch(patch, options = {}) {
+  const files = [];
+  const maxLines = positiveInteger(options.maxLines);
+  let currentHunk = null;
+  let currentCursor = null;
+  let totalLineCount = 0;
+  let renderedLineCount = 0;
+  let previousHunkDiffLineWasRendered = false;
+  const lines = preparePatchLines(patch);
+  for (let index = 0;index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    const line = stripLineTerminatorCarriageReturn(rawLine);
+    const nextRawLine = lines[index + 1];
+    const nextLine = nextRawLine === undefined ? undefined : stripLineTerminatorCarriageReturn(nextRawLine);
+    const nextNextRawLine = lines[index + 2];
+    const nextNextLine = nextNextRawLine === undefined ? undefined : stripLineTerminatorCarriageReturn(nextNextRawLine);
+    const nextNextNextRawLine = lines[index + 3];
+    const nextNextNextLine = nextNextNextRawLine === undefined ? undefined : stripLineTerminatorCarriageReturn(nextNextNextRawLine);
+    const nextNextNextNextRawLine = lines[index + 4];
+    const nextNextNextNextLine = nextNextNextNextRawLine === undefined ? undefined : stripLineTerminatorCarriageReturn(nextNextNextNextRawLine);
+    if (line === "" && files.length === 0)
+      continue;
+    if (line.startsWith("diff --git ")) {
+      files.push(createParsedGitFile(line));
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (line.startsWith("diff ")) {
+      startFile(files, line);
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    const previousFileIsGitDiff = files[files.length - 1]?.header?.startsWith("diff --git ");
+    const previousFile = files[files.length - 1];
+    const previousHunkIsComplete = currentHunk && currentCursor && hunkIsComplete(currentHunk, currentCursor);
+    const shouldKeepAsGitMetadata = previousFileIsGitDiff && previousFile !== undefined && !previousHunkIsComplete && isGitBinaryNoticeMetadata(previousFile, line);
+    if (isStandaloneRecursiveDiffMetadata(line) && (!currentHunk || !currentCursor || previousHunkIsComplete) && !shouldKeepAsGitMetadata) {
+      totalLineCount += 1;
+      if (renderedLineCount < maxLines) {
+        startFile(files, line);
+        renderedLineCount += 1;
+      }
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (currentHunk && currentCursor && line.startsWith("--- ") && nextLine?.startsWith("+++ ") && nextNextLine?.startsWith("@@ ")) {
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+    }
+    if (currentHunk && currentCursor && (line.startsWith("--- ") || line.startsWith("+++ "))) {
+      const result2 = readHunkLine(currentHunk, currentCursor, rawLine, renderedLineCount, maxLines, previousHunkDiffLineWasRendered);
+      renderedLineCount = result2.renderedLineCount;
+      if (result2.lineWasRead) {
+        totalLineCount += 1;
+        previousHunkDiffLineWasRendered = result2.lineWasRendered;
+      }
+      continue;
+    }
+    if (currentHunk && currentCursor && (line.startsWith("\\ ") || !hunkIsComplete(currentHunk, currentCursor))) {
+      const result2 = readHunkLine(currentHunk, currentCursor, rawLine, renderedLineCount, maxLines, previousHunkDiffLineWasRendered);
+      renderedLineCount = result2.renderedLineCount;
+      if (result2.lineWasRead) {
+        totalLineCount += 1;
+        previousHunkDiffLineWasRendered = result2.lineWasRendered;
+      }
+      continue;
+    }
+    if (isIndexedUnifiedFilePrelude(line, nextLine, nextNextLine, nextNextNextLine, nextNextNextNextLine)) {
+      startFile(files, line);
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      const file = ensureFileForOldHeader(files);
+      file.oldPath = parseGitFileSidePath(file, line.slice(4), file.oldPath);
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const file = ensureFile(files);
+      file.newPath = parseGitFileSidePath(file, line.slice(4), file.newPath);
+      currentHunk = null;
+      currentCursor = null;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (line.startsWith("@@ ")) {
+      const file = ensureFile(files);
+      const { hunk, cursor } = createHunk(line);
+      file.hunks.push(hunk);
+      currentHunk = hunk;
+      currentCursor = cursor;
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (currentHunk && currentCursor && hunkIsComplete(currentHunk, currentCursor) && !hunkCanReadAfterZeroCountComplete(currentHunk, rawLine)) {
+      totalLineCount += 1;
+      if (renderedLineCount < maxLines) {
+        currentHunk.lines.push(createHunkMetadataLine(line));
+        renderedLineCount += 1;
+      }
+      previousHunkDiffLineWasRendered = false;
+      continue;
+    }
+    if (!currentHunk || !currentCursor) {
+      const result2 = pushMetadata(files, line, renderedLineCount, maxLines);
+      renderedLineCount = result2.renderedLineCount;
+      totalLineCount += 1;
+      continue;
+    }
+    const result = readHunkLine(currentHunk, currentCursor, rawLine, renderedLineCount, maxLines, previousHunkDiffLineWasRendered);
+    renderedLineCount = result.renderedLineCount;
+    if (result.lineWasRead) {
+      totalLineCount += 1;
+      previousHunkDiffLineWasRendered = result.lineWasRendered;
+    }
+  }
+  if (files.length === 0 && totalLineCount === 0)
+    return createEmptyParseResult();
+  return {
+    files: pruneFiles(files),
+    totalLineCount,
+    renderedLineCount,
+    truncated: renderedLineCount < totalLineCount
+  };
+}
+
+// src/components/source-diff-viewer/source-diff-viewer.svelte
+function Source_diff_viewer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      patch,
+      ariaLabel,
+      "aria-label": nativeAriaLabel,
+      "aria-labelledby": nativeAriaLabelledBy,
+      maxLines = 1000,
+      lineNumbers = true,
+      emptyMessage = "No patch lines to display.",
+      class: className,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const parsedPatch = $.derived(() => parseUnifiedPatch(patch, { maxLines }));
+    const hasPatchContent = $.derived(() => parsedPatch().files.length > 0 || parsedPatch().totalLineCount > 0);
+    const normalizedAriaLabelledBy = $.derived(() => normalizeAriaLabel(nativeAriaLabelledBy));
+    const normalizedAriaLabel = $.derived(() => normalizedAriaLabelledBy() ? undefined : normalizeAriaLabel(ariaLabel) ?? normalizeAriaLabel(nativeAriaLabel) ?? "Source diff");
+    function getSourceDiffLineText(line) {
+      if (line.kind === "metadata")
+        return line.metadataPrefix ? `${line.metadataPrefix} ${line.content}` : line.content;
+      const prefix = line.kind === "addition" ? "+" : line.kind === "removal" ? "-" : " ";
+      return `${prefix}${line.content}`;
+    }
+    function normalizeAriaLabel(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : undefined;
+    }
+    $$renderer2.push(`<div${$.attributes({
+      ...rest,
+      class: $.clsx(classNames("cinder-source-diff-viewer", className)),
+      role: "region",
+      "aria-label": normalizedAriaLabel(),
+      "aria-labelledby": normalizedAriaLabelledBy()
+    })}>`);
+    if (!hasPatchContent()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p class="cinder-source-diff-viewer__empty">${$.escape(emptyMessage)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      if (parsedPatch().truncated) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="cinder-source-diff-viewer__notice" role="status">Showing first ${$.escape(parsedPatch().renderedLineCount)} of ${$.escape(parsedPatch().totalLineCount)} diff lines.</div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--> <!--[-->`);
+      const each_array = $.ensure_array_like(parsedPatch().files);
+      for (let fileIndex = 0, $$length = each_array.length;fileIndex < $$length; fileIndex++) {
+        let file = each_array[fileIndex];
+        const fileLabel = getSourceDiffFileLabel(file);
+        $$renderer2.push(`<section class="cinder-source-diff-viewer__file"${$.attr("aria-label", fileLabel)}><header class="cinder-source-diff-viewer__file-header"><span class="cinder-source-diff-viewer__file-path">${$.escape(fileLabel)}</span></header> `);
+        if (file.metadata.length > 0) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<div class="cinder-source-diff-viewer__metadata" role="group" aria-label="File metadata"><!--[-->`);
+          const each_array_1 = $.ensure_array_like(file.metadata);
+          for (let metadataIndex = 0, $$length2 = each_array_1.length;metadataIndex < $$length2; metadataIndex++) {
+            let metadataLine = each_array_1[metadataIndex];
+            $$renderer2.push(`<code>${$.escape(metadataLine)}</code>`);
+          }
+          $$renderer2.push(`<!--]--></div>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]--> <!--[-->`);
+        const each_array_2 = $.ensure_array_like(file.hunks);
+        for (let hunkIndex = 0, $$length2 = each_array_2.length;hunkIndex < $$length2; hunkIndex++) {
+          let hunk = each_array_2[hunkIndex];
+          if (hunk.lines.length > 0) {
+            $$renderer2.push("<!--[0-->");
+            $$renderer2.push(`<div class="cinder-source-diff-viewer__hunk"><div class="cinder-source-diff-viewer__hunk-header">${$.escape(hunk.header)}</div> <section class="cinder-source-diff-viewer__lines"${$.attr("aria-label", `${fileLabel} ${hunk.header} lines`)}><!--[-->`);
+            const each_array_3 = $.ensure_array_like(hunk.lines);
+            for (let lineIndex = 0, $$length3 = each_array_3.length;lineIndex < $$length3; lineIndex++) {
+              let line = each_array_3[lineIndex];
+              $$renderer2.push(`<div class="cinder-source-diff-viewer__line"${$.attr("data-cinder-line-kind", line.kind)}>`);
+              if (lineNumbers) {
+                $$renderer2.push("<!--[0-->");
+                $$renderer2.push(`<span class="cinder-source-diff-viewer__line-number" aria-hidden="true">${$.escape(line.oldLineNumber ?? "")}</span> <span class="cinder-source-diff-viewer__line-number" aria-hidden="true">${$.escape(line.newLineNumber ?? "")}</span>`);
+              } else {
+                $$renderer2.push("<!--[-1-->");
+              }
+              $$renderer2.push(`<!--]--> <span class="cinder-sr-only">${$.escape(getSourceDiffLineLabel(line))}</span> <code class="cinder-source-diff-viewer__line-code" aria-hidden="true">${$.escape(getSourceDiffLineText(line))}</code></div>`);
+            }
+            $$renderer2.push(`<!--]--></section></div>`);
+          } else {
+            $$renderer2.push("<!--[-1-->");
+          }
+          $$renderer2.push(`<!--]-->`);
+        }
+        $$renderer2.push(`<!--]--></section>`);
+      }
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  }, Source_diff_viewer);
+}
+
+// src/components/source-diff-viewer/index.ts
+var source_diff_viewer_default = Source_diff_viewer;
+export { getSourceDiffFileLabel, getSourceDiffLineLabel, parseUnifiedPatch, Source_diff_viewer, source_diff_viewer_default };
+
+//# debugId=96CC33BA09CDAF6564756E2164756E21