@lostgradient/cinder 0.5.0 → 0.6.0

package/dist/components/source-diff-viewer/index.js

@@ -0,0 +1,886 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/source-diff-viewer/index.ts
+import"@lostgradient/cinder/source-diff-viewer/styles";
+
+// src/components/source-diff-viewer/source-diff-viewer.svelte
+import"svelte/internal/disclose-version";
+import * as $ from "svelte/internal/client";
+
+// src/utilities/class-names.ts
+function classNames(...parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0).join(" ");
+}
+
+// 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
+var root_1 = $.from_html(`<p class="cinder-source-diff-viewer__empty"> </p>`);
+var root_3 = $.from_html(`<div class="cinder-source-diff-viewer__notice" role="status"> </div>`);
+var root_6 = $.from_html(`<code> </code>`);
+var root_5 = $.from_html(`<div class="cinder-source-diff-viewer__metadata" role="group" aria-label="File metadata"></div>`);
+var root_10 = $.from_html(`<span class="cinder-source-diff-viewer__line-number" aria-hidden="true"> </span> <span class="cinder-source-diff-viewer__line-number" aria-hidden="true"> </span>`, 1);
+var root_9 = $.from_html(`<div class="cinder-source-diff-viewer__line"><!> <span class="cinder-sr-only"> </span> <code class="cinder-source-diff-viewer__line-code" aria-hidden="true"> </code></div>`);
+var root_8 = $.from_html(`<div class="cinder-source-diff-viewer__hunk"><div class="cinder-source-diff-viewer__hunk-header"> </div> <section class="cinder-source-diff-viewer__lines"></section></div>`);
+var root_4 = $.from_html(`<section class="cinder-source-diff-viewer__file"><header class="cinder-source-diff-viewer__file-header"><span class="cinder-source-diff-viewer__file-path"> </span></header> <!> <!></section>`);
+var root_2 = $.from_html(`<!> <!>`, 1);
+var root = $.from_html(`<div><!></div>`);
+function Source_diff_viewer($$anchor, $$props) {
+  $.push($$props, true);
+  let maxLines = $.prop($$props, "maxLines", 3, 1000), lineNumbers = $.prop($$props, "lineNumbers", 3, true), emptyMessage = $.prop($$props, "emptyMessage", 3, "No patch lines to display."), rest = $.rest_props($$props, [
+    "$$slots",
+    "$$events",
+    "$$legacy",
+    "patch",
+    "ariaLabel",
+    "aria-label",
+    "aria-labelledby",
+    "maxLines",
+    "lineNumbers",
+    "emptyMessage",
+    "class"
+  ]);
+  const parsedPatch = $.derived(() => parseUnifiedPatch($$props.patch, { maxLines: maxLines() }));
+  const hasPatchContent = $.derived(() => $.get(parsedPatch).files.length > 0 || $.get(parsedPatch).totalLineCount > 0);
+  const normalizedAriaLabelledBy = $.derived(() => normalizeAriaLabel($$props["aria-labelledby"]));
+  const normalizedAriaLabel = $.derived(() => $.get(normalizedAriaLabelledBy) ? undefined : normalizeAriaLabel($$props.ariaLabel) ?? normalizeAriaLabel($$props["aria-label"]) ?? "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;
+  }
+  var div = root();
+  $.attribute_effect(div, ($0) => ({
+    ...rest,
+    class: $0,
+    role: "region",
+    "aria-label": $.get(normalizedAriaLabel),
+    "aria-labelledby": $.get(normalizedAriaLabelledBy)
+  }), [() => classNames("cinder-source-diff-viewer", $$props.class)]);
+  var node = $.child(div);
+  {
+    var consequent = ($$anchor2) => {
+      var p = root_1();
+      var text = $.child(p, true);
+      $.reset(p);
+      $.template_effect(() => $.set_text(text, emptyMessage()));
+      $.append($$anchor2, p);
+    };
+    var alternate = ($$anchor2) => {
+      var fragment = root_2();
+      var node_1 = $.first_child(fragment);
+      {
+        var consequent_1 = ($$anchor3) => {
+          var div_1 = root_3();
+          var text_1 = $.child(div_1);
+          $.reset(div_1);
+          $.template_effect(() => $.set_text(text_1, `Showing first ${$.get(parsedPatch).renderedLineCount ?? ""} of ${$.get(parsedPatch).totalLineCount ?? ""} diff lines.`));
+          $.append($$anchor3, div_1);
+        };
+        $.if(node_1, ($$render) => {
+          if ($.get(parsedPatch).truncated)
+            $$render(consequent_1);
+        });
+      }
+      var node_2 = $.sibling(node_1, 2);
+      $.each(node_2, 19, () => $.get(parsedPatch).files, (file, fileIndex) => `${fileIndex}:${file.header ?? `${file.oldPath ?? ""}:${file.newPath ?? ""}`}`, ($$anchor3, file) => {
+        const fileLabel = $.derived(() => getSourceDiffFileLabel($.get(file)));
+        var section = root_4();
+        var header = $.child(section);
+        var span = $.child(header);
+        var text_2 = $.child(span, true);
+        $.reset(span);
+        $.reset(header);
+        var node_3 = $.sibling(header, 2);
+        {
+          var consequent_2 = ($$anchor4) => {
+            var div_2 = root_5();
+            $.each(div_2, 23, () => $.get(file).metadata, (metadataLine, metadataIndex) => `${metadataIndex}:${metadataLine}`, ($$anchor5, metadataLine) => {
+              var code = root_6();
+              var text_3 = $.child(code, true);
+              $.reset(code);
+              $.template_effect(() => $.set_text(text_3, $.get(metadataLine)));
+              $.append($$anchor5, code);
+            });
+            $.reset(div_2);
+            $.append($$anchor4, div_2);
+          };
+          $.if(node_3, ($$render) => {
+            if ($.get(file).metadata.length > 0)
+              $$render(consequent_2);
+          });
+        }
+        var node_4 = $.sibling(node_3, 2);
+        $.each(node_4, 19, () => $.get(file).hunks, (hunk, hunkIndex) => `${hunkIndex}:${hunk.header}`, ($$anchor4, hunk) => {
+          var fragment_1 = $.comment();
+          var node_5 = $.first_child(fragment_1);
+          {
+            var consequent_4 = ($$anchor5) => {
+              var div_3 = root_8();
+              var div_4 = $.child(div_3);
+              var text_4 = $.child(div_4, true);
+              $.reset(div_4);
+              var section_1 = $.sibling(div_4, 2);
+              $.each(section_1, 23, () => $.get(hunk).lines, (line, lineIndex) => `${lineIndex}:${line.kind}:${line.oldLineNumber ?? ""}:${line.newLineNumber ?? ""}`, ($$anchor6, line) => {
+                var div_5 = root_9();
+                var node_6 = $.child(div_5);
+                {
+                  var consequent_3 = ($$anchor7) => {
+                    var fragment_2 = root_10();
+                    var span_1 = $.first_child(fragment_2);
+                    var text_5 = $.child(span_1, true);
+                    $.reset(span_1);
+                    var span_2 = $.sibling(span_1, 2);
+                    var text_6 = $.child(span_2, true);
+                    $.reset(span_2);
+                    $.template_effect(() => {
+                      $.set_text(text_5, $.get(line).oldLineNumber ?? "");
+                      $.set_text(text_6, $.get(line).newLineNumber ?? "");
+                    });
+                    $.append($$anchor7, fragment_2);
+                  };
+                  $.if(node_6, ($$render) => {
+                    if (lineNumbers())
+                      $$render(consequent_3);
+                  });
+                }
+                var span_3 = $.sibling(node_6, 2);
+                var text_7 = $.child(span_3, true);
+                $.reset(span_3);
+                var code_1 = $.sibling(span_3, 2);
+                var text_8 = $.child(code_1, true);
+                $.reset(code_1);
+                $.reset(div_5);
+                $.template_effect(($0, $1) => {
+                  $.set_attribute(div_5, "data-cinder-line-kind", $.get(line).kind);
+                  $.set_text(text_7, $0);
+                  $.set_text(text_8, $1);
+                }, [
+                  () => getSourceDiffLineLabel($.get(line)),
+                  () => getSourceDiffLineText($.get(line))
+                ]);
+                $.append($$anchor6, div_5);
+              });
+              $.reset(section_1);
+              $.reset(div_3);
+              $.template_effect(() => {
+                $.set_text(text_4, $.get(hunk).header);
+                $.set_attribute(section_1, "aria-label", `${$.get(fileLabel)} ${$.get(hunk).header} lines`);
+              });
+              $.append($$anchor5, div_3);
+            };
+            $.if(node_5, ($$render) => {
+              if ($.get(hunk).lines.length > 0)
+                $$render(consequent_4);
+            });
+          }
+          $.append($$anchor4, fragment_1);
+        });
+        $.reset(section);
+        $.template_effect(() => {
+          $.set_attribute(section, "aria-label", $.get(fileLabel));
+          $.set_text(text_2, $.get(fileLabel));
+        });
+        $.append($$anchor3, section);
+      });
+      $.append($$anchor2, fragment);
+    };
+    $.if(node, ($$render) => {
+      if (!$.get(hasPatchContent))
+        $$render(consequent);
+      else
+        $$render(alternate, -1);
+    });
+  }
+  $.reset(div);
+  $.append($$anchor, div);
+  $.pop();
+}
+
+// src/components/source-diff-viewer/index.ts
+var source_diff_viewer_default = Source_diff_viewer;
+export {
+  parseUnifiedPatch,
+  getSourceDiffLineLabel,
+  getSourceDiffFileLabel,
+  source_diff_viewer_default as default,
+  Source_diff_viewer as SourceDiffViewer
+};
+
+//# debugId=F6A0BEF75DD772D364756E2164756E21