@pierre/diffs 1.3.0-beta.9 → 1.3.0-rc.2

package/dist/utils/annotationHelpers.js

@@ -0,0 +1,29 @@
+//#region src/utils/annotationHelpers.ts
+/** Narrow an annotation to the side-tagged diff shape. */
+function isDiffAnnotation(annotation) {
+	return "side" in annotation;
+}
+/** Narrow an annotation to the side-less file shape. */
+function isFileAnnotation(annotation) {
+	return !isDiffAnnotation(annotation);
+}
+/**
+* Narrow a homogeneous editor annotation collection to diff annotations.
+* Empty collections return true because they are valid for either shape.
+*/
+function isDiffAnnotationCollection(annotations) {
+	const first = annotations[0];
+	return first == null || isDiffAnnotation(first);
+}
+/**
+* Narrow a homogeneous editor annotation collection to file annotations.
+* Empty collections return true because they are valid for either shape.
+*/
+function isFileAnnotationCollection(annotations) {
+	const first = annotations[0];
+	return first == null || isFileAnnotation(first);
+}
+//#endregion
+export { isDiffAnnotation, isDiffAnnotationCollection, isFileAnnotation, isFileAnnotationCollection };
+
+//# sourceMappingURL=annotationHelpers.js.map

package/dist/utils/annotationHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotationHelpers.js","names":[],"sources":["../../src/utils/annotationHelpers.ts"],"sourcesContent":["import type { DiffLineAnnotation, LineAnnotation } from '../types';\n\n/** Narrow an annotation to the side-tagged diff shape. */\nexport function isDiffAnnotation<LAnnotation = undefined>(\n  annotation: LineAnnotation<LAnnotation> | DiffLineAnnotation<LAnnotation>\n): annotation is DiffLineAnnotation<LAnnotation> {\n  return 'side' in annotation;\n}\n\n/** Narrow an annotation to the side-less file shape. */\nexport function isFileAnnotation<LAnnotation = undefined>(\n  annotation: LineAnnotation<LAnnotation> | DiffLineAnnotation<LAnnotation>\n): annotation is LineAnnotation<LAnnotation> {\n  return !isDiffAnnotation(annotation);\n}\n\n/**\n * Narrow a homogeneous editor annotation collection to diff annotations.\n * Empty collections return true because they are valid for either shape.\n */\nexport function isDiffAnnotationCollection<LAnnotation = undefined>(\n  annotations: LineAnnotation<LAnnotation>[] | DiffLineAnnotation<LAnnotation>[]\n): annotations is DiffLineAnnotation<LAnnotation>[] {\n  const first = annotations[0];\n  return first == null || isDiffAnnotation(first);\n}\n\n/**\n * Narrow a homogeneous editor annotation collection to file annotations.\n * Empty collections return true because they are valid for either shape.\n */\nexport function isFileAnnotationCollection<LAnnotation = undefined>(\n  annotations: LineAnnotation<LAnnotation>[] | DiffLineAnnotation<LAnnotation>[]\n): annotations is LineAnnotation<LAnnotation>[] {\n  const first = annotations[0];\n  return first == null || isFileAnnotation(first);\n}\n"],"mappings":";;AAGA,SAAgB,iBACd,YAC+C;CAC/C,OAAO,UAAU;AACnB;;AAGA,SAAgB,iBACd,YAC2C;CAC3C,OAAO,CAAC,iBAAiB,UAAU;AACrC;;;;;AAMA,SAAgB,2BACd,aACkD;CAClD,MAAM,QAAQ,YAAY;CAC1B,OAAO,SAAS,QAAQ,iBAAiB,KAAK;AAChD;;;;;AAMA,SAAgB,2BACd,aAC8C;CAC9C,MAAM,QAAQ,YAAY;CAC1B,OAAO,SAAS,QAAQ,iBAAiB,KAAK;AAChD"}

package/dist/utils/computeFileOffsets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeFileOffsets.d.ts","names":[],"sources":["../../src/utils/computeFileOffsets.ts"],"mappings":";;AAMA;;iBAAgB,kBAAA,CAAmB,QAAgB;;AAAA;AAyBnD;;;;AAAgD;iBAAhC,eAAA,CAAgB,QAAgB;;;;AAuBM;iBAAtC,qBAAA,CAAsB,QAAgB"}
+{"version":3,"file":"computeFileOffsets.d.ts","names":[],"sources":["../../src/utils/computeFileOffsets.ts"],"mappings":";;AAQA;;iBAAgB,kBAAA,CAAmB,QAAgB;;AAAA;AA2DnD;;;;AAAgD;iBAAhC,eAAA,CAAgB,QAAgB;;;;AAuBM;iBAAtC,qBAAA,CAAsB,QAAgB"}

package/dist/utils/computeFileOffsets.js

@@ -1,16 +1,45 @@
 //#region src/utils/computeFileOffsets.ts
 const LINE_FEED = 10;
 const CARRIAGE_RETURN = 13;
+const DENSE_LINE_BREAK_BLOCK_SIZE = 4;
+const DENSE_LINE_BREAK_BLOCK_SPAN = 40;
 /**
 * Computes line start offsets for a string.
 */
 function computeLineOffsets(contents) {
 	const offsets = [0];
-	for (let i = 0; i < contents.length; i++) {
-		const char = contents.charCodeAt(i);
-		if (char === LINE_FEED || char === CARRIAGE_RETURN) {
-			if (char === CARRIAGE_RETURN && i + 1 < contents.length && contents.charCodeAt(i + 1) === LINE_FEED) i++;
-			offsets.push(i + 1);
+	let carriageReturn = contents.indexOf("\r");
+	let lineFeed = contents.indexOf("\n");
+	let blockStart = 0;
+	let blockBreaks = 0;
+	while (carriageReturn !== -1 || lineFeed !== -1) {
+		let nextOffset;
+		if (carriageReturn !== -1 && (lineFeed === -1 || carriageReturn < lineFeed)) if (lineFeed === carriageReturn + 1) {
+			nextOffset = lineFeed + 1;
+			carriageReturn = contents.indexOf("\r", nextOffset);
+			lineFeed = contents.indexOf("\n", nextOffset);
+		} else {
+			nextOffset = carriageReturn + 1;
+			carriageReturn = contents.indexOf("\r", nextOffset);
+		}
+		else {
+			nextOffset = lineFeed + 1;
+			lineFeed = contents.indexOf("\n", nextOffset);
+		}
+		offsets.push(nextOffset);
+		if (++blockBreaks === DENSE_LINE_BREAK_BLOCK_SIZE) {
+			if (nextOffset - blockStart <= DENSE_LINE_BREAK_BLOCK_SPAN) {
+				for (let i = nextOffset; i < contents.length; i++) {
+					const char = contents.charCodeAt(i);
+					if (char === LINE_FEED || char === CARRIAGE_RETURN) {
+						if (char === CARRIAGE_RETURN && i + 1 < contents.length && contents.charCodeAt(i + 1) === LINE_FEED) i++;
+						offsets.push(i + 1);
+					}
+				}
+				return offsets;
+			}
+			blockStart = nextOffset;
+			blockBreaks = 0;
 		}
 	}
 	return offsets;

package/dist/utils/computeFileOffsets.js.map

@@ -1 +1 @@
-{"version":3,"file":"computeFileOffsets.js","names":[],"sources":["../../src/utils/computeFileOffsets.ts"],"sourcesContent":["const LINE_FEED = 10; // \\n\nconst CARRIAGE_RETURN = 13; // \\r\n\n/**\n * Computes line start offsets for a string.\n */\nexport function computeLineOffsets(contents: string): number[] {\n  const offsets: number[] = [0];\n  for (let i = 0; i < contents.length; i++) {\n    const char = contents.charCodeAt(i);\n    if (char === LINE_FEED || char === CARRIAGE_RETURN) {\n      if (\n        char === CARRIAGE_RETURN &&\n        i + 1 < contents.length &&\n        contents.charCodeAt(i + 1) === LINE_FEED\n      ) {\n        i++;\n      }\n      offsets.push(i + 1);\n    }\n  }\n  return offsets;\n}\n\n/**\n * Counts line breaks in a string, treating `\\n`, `\\r`, and `\\r\\n` the same way\n * {@link computeLineOffsets} does (a `\\r\\n` pair is one break). Mirrors that\n * scan but counts in a single pass instead of building and discarding an\n * offsets array, so sizing the changed-line range for large edits stays cheap.\n * A unit test asserts it stays in lockstep with `computeLineOffsets`.\n */\nexport function countLineBreaks(contents: string): number {\n  let count = 0;\n  for (let i = 0; i < contents.length; i++) {\n    const char = contents.charCodeAt(i);\n    if (char === LINE_FEED || char === CARRIAGE_RETURN) {\n      // Skip the `\\n` of a `\\r\\n` pair so it counts as one break, not two.\n      if (\n        char === CARRIAGE_RETURN &&\n        i + 1 < contents.length &&\n        contents.charCodeAt(i + 1) === LINE_FEED\n      ) {\n        i++;\n      }\n      count++;\n    }\n  }\n  return count;\n}\n\n/**\n * Splits file contents into lines aligned with {@link computeLineOffsets}.\n * Unlike splitFileContents, a trailing newline produces a final empty line.\n */\nexport function linesFromFileContents(contents: string): string[] {\n  const offsets = computeLineOffsets(contents);\n  const lines = Array.from({ length: offsets.length }, (_, i) => {\n    const start = offsets[i];\n    const end = offsets[i + 1] ?? contents.length;\n    return contents.slice(start, end);\n  });\n  return lines;\n}\n"],"mappings":";AAAA,MAAM,YAAY;AAClB,MAAM,kBAAkB;;;;AAKxB,SAAgB,mBAAmB,UAA4B;CAC7D,MAAM,UAAoB,CAAC,CAAC;CAC5B,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,OAAO,SAAS,WAAW,CAAC;EAClC,IAAI,SAAS,aAAa,SAAS,iBAAiB;GAClD,IACE,SAAS,mBACT,IAAI,IAAI,SAAS,UACjB,SAAS,WAAW,IAAI,CAAC,MAAM,WAE/B;GAEF,QAAQ,KAAK,IAAI,CAAC;EACpB;CACF;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,gBAAgB,UAA0B;CACxD,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,OAAO,SAAS,WAAW,CAAC;EAClC,IAAI,SAAS,aAAa,SAAS,iBAAiB;GAElD,IACE,SAAS,mBACT,IAAI,IAAI,SAAS,UACjB,SAAS,WAAW,IAAI,CAAC,MAAM,WAE/B;GAEF;EACF;CACF;CACA,OAAO;AACT;;;;;AAMA,SAAgB,sBAAsB,UAA4B;CAChE,MAAM,UAAU,mBAAmB,QAAQ;CAM3C,OALc,MAAM,KAAK,EAAE,QAAQ,QAAQ,OAAO,IAAI,GAAG,MAAM;EAC7D,MAAM,QAAQ,QAAQ;EACtB,MAAM,MAAM,QAAQ,IAAI,MAAM,SAAS;EACvC,OAAO,SAAS,MAAM,OAAO,GAAG;CAClC,CACW;AACb"}
+{"version":3,"file":"computeFileOffsets.js","names":[],"sources":["../../src/utils/computeFileOffsets.ts"],"sourcesContent":["const LINE_FEED = 10; // \\n\nconst CARRIAGE_RETURN = 13; // \\r\nconst DENSE_LINE_BREAK_BLOCK_SIZE = 4;\nconst DENSE_LINE_BREAK_BLOCK_SPAN = 40;\n\n/**\n * Computes line start offsets for a string.\n */\nexport function computeLineOffsets(contents: string): number[] {\n  const offsets: number[] = [0];\n  let carriageReturn = contents.indexOf('\\r');\n  let lineFeed = contents.indexOf('\\n');\n  let blockStart = 0;\n  let blockBreaks = 0;\n  while (carriageReturn !== -1 || lineFeed !== -1) {\n    let nextOffset: number;\n    if (\n      carriageReturn !== -1 &&\n      (lineFeed === -1 || carriageReturn < lineFeed)\n    ) {\n      if (lineFeed === carriageReturn + 1) {\n        nextOffset = lineFeed + 1;\n        carriageReturn = contents.indexOf('\\r', nextOffset);\n        lineFeed = contents.indexOf('\\n', nextOffset);\n      } else {\n        nextOffset = carriageReturn + 1;\n        carriageReturn = contents.indexOf('\\r', nextOffset);\n      }\n    } else {\n      nextOffset = lineFeed + 1;\n      lineFeed = contents.indexOf('\\n', nextOffset);\n    }\n    offsets.push(nextOffset);\n\n    if (++blockBreaks === DENSE_LINE_BREAK_BLOCK_SIZE) {\n      if (nextOffset - blockStart <= DENSE_LINE_BREAK_BLOCK_SPAN) {\n        // Native searches win on source-like lines; a character scan is faster\n        // once line breaks become unusually dense.\n        for (let i = nextOffset; i < contents.length; i++) {\n          const char = contents.charCodeAt(i);\n          if (char === LINE_FEED || char === CARRIAGE_RETURN) {\n            if (\n              char === CARRIAGE_RETURN &&\n              i + 1 < contents.length &&\n              contents.charCodeAt(i + 1) === LINE_FEED\n            ) {\n              i++;\n            }\n            offsets.push(i + 1);\n          }\n        }\n        return offsets;\n      }\n      blockStart = nextOffset;\n      blockBreaks = 0;\n    }\n  }\n  return offsets;\n}\n\n/**\n * Counts line breaks in a string, treating `\\n`, `\\r`, and `\\r\\n` the same way\n * {@link computeLineOffsets} does (a `\\r\\n` pair is one break). Mirrors that\n * scan but counts in a single pass instead of building and discarding an\n * offsets array, so sizing the changed-line range for large edits stays cheap.\n * A unit test asserts it stays in lockstep with `computeLineOffsets`.\n */\nexport function countLineBreaks(contents: string): number {\n  let count = 0;\n  for (let i = 0; i < contents.length; i++) {\n    const char = contents.charCodeAt(i);\n    if (char === LINE_FEED || char === CARRIAGE_RETURN) {\n      // Skip the `\\n` of a `\\r\\n` pair so it counts as one break, not two.\n      if (\n        char === CARRIAGE_RETURN &&\n        i + 1 < contents.length &&\n        contents.charCodeAt(i + 1) === LINE_FEED\n      ) {\n        i++;\n      }\n      count++;\n    }\n  }\n  return count;\n}\n\n/**\n * Splits file contents into lines aligned with {@link computeLineOffsets}.\n * Unlike splitFileContents, a trailing newline produces a final empty line.\n */\nexport function linesFromFileContents(contents: string): string[] {\n  const offsets = computeLineOffsets(contents);\n  const lines = Array.from({ length: offsets.length }, (_, i) => {\n    const start = offsets[i];\n    const end = offsets[i + 1] ?? contents.length;\n    return contents.slice(start, end);\n  });\n  return lines;\n}\n"],"mappings":";AAAA,MAAM,YAAY;AAClB,MAAM,kBAAkB;AACxB,MAAM,8BAA8B;AACpC,MAAM,8BAA8B;;;;AAKpC,SAAgB,mBAAmB,UAA4B;CAC7D,MAAM,UAAoB,CAAC,CAAC;CAC5B,IAAI,iBAAiB,SAAS,QAAQ,IAAI;CAC1C,IAAI,WAAW,SAAS,QAAQ,IAAI;CACpC,IAAI,aAAa;CACjB,IAAI,cAAc;CAClB,OAAO,mBAAmB,MAAM,aAAa,IAAI;EAC/C,IAAI;EACJ,IACE,mBAAmB,OAClB,aAAa,MAAM,iBAAiB,WAErC,IAAI,aAAa,iBAAiB,GAAG;GACnC,aAAa,WAAW;GACxB,iBAAiB,SAAS,QAAQ,MAAM,UAAU;GAClD,WAAW,SAAS,QAAQ,MAAM,UAAU;EAC9C,OAAO;GACL,aAAa,iBAAiB;GAC9B,iBAAiB,SAAS,QAAQ,MAAM,UAAU;EACpD;OACK;GACL,aAAa,WAAW;GACxB,WAAW,SAAS,QAAQ,MAAM,UAAU;EAC9C;EACA,QAAQ,KAAK,UAAU;EAEvB,IAAI,EAAE,gBAAgB,6BAA6B;GACjD,IAAI,aAAa,cAAc,6BAA6B;IAG1D,KAAK,IAAI,IAAI,YAAY,IAAI,SAAS,QAAQ,KAAK;KACjD,MAAM,OAAO,SAAS,WAAW,CAAC;KAClC,IAAI,SAAS,aAAa,SAAS,iBAAiB;MAClD,IACE,SAAS,mBACT,IAAI,IAAI,SAAS,UACjB,SAAS,WAAW,IAAI,CAAC,MAAM,WAE/B;MAEF,QAAQ,KAAK,IAAI,CAAC;KACpB;IACF;IACA,OAAO;GACT;GACA,aAAa;GACb,cAAc;EAChB;CACF;CACA,OAAO;AACT;;;;;;;;AASA,SAAgB,gBAAgB,UAA0B;CACxD,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,OAAO,SAAS,WAAW,CAAC;EAClC,IAAI,SAAS,aAAa,SAAS,iBAAiB;GAElD,IACE,SAAS,mBACT,IAAI,IAAI,SAAS,UACjB,SAAS,WAAW,IAAI,CAAC,MAAM,WAE/B;GAEF;EACF;CACF;CACA,OAAO;AACT;;;;;AAMA,SAAgB,sBAAsB,UAA4B;CAChE,MAAM,UAAU,mBAAmB,QAAQ;CAM3C,OALc,MAAM,KAAK,EAAE,QAAQ,QAAQ,OAAO,IAAI,GAAG,MAAM;EAC7D,MAAM,QAAQ,QAAQ;EACtB,MAAM,MAAM,QAAQ,IAAI,MAAM,SAAS;EACvC,OAAO,SAAS,MAAM,OAAO,GAAG;CAClC,CACW;AACb"}

package/dist/utils/editSessionHunks.d.ts

@@ -0,0 +1,66 @@
+import { FileDiffMetadata, HunkExpansionRegion } from "../types.js";
+import { CreatePatchOptionsNonabortable } from "diff";
+
+//#region src/utils/editSessionHunks.d.ts
+interface DivergenceCore {
+  start: number;
+  deletionEnd: number;
+  additionEnd: number;
+}
+interface PreviousRegionSpan {
+  firstIndex: number;
+  lastIndex: number;
+}
+/** Maps rebuilt regions back to the previous skeleton for expansion remapping. */
+interface SessionRegionChange {
+  regions: Array<PreviousRegionSpan | undefined>;
+}
+/**
+ * Drops the editor document's phantom trailing empty line (a document ending
+ * in a newline exposes one extra empty line the parsed diff never contains)
+ * so session line arrays compare like parse-derived ones.
+ */
+declare function normalizeEditorLines(lines: string[]): string[];
+/**
+ * Find the complete old/current divergence core. The old side is immutable
+ * during an edit session, so this result needs no prior-pass snapshot.
+ */
+declare function findDivergenceCore(deletionLines: string[], additionLines: string[]): DivergenceCore | undefined;
+/**
+ * Rebuild the session skeleton as a pure function of the immutable old lines,
+ * current new lines, and old-side ranges of the previous regions. One
+ * canonical parse supplies the same change blocks that session exit will use.
+ */
+declare function rebuildSessionHunks(diff: FileDiffMetadata, parseDiffOptions?: CreatePatchOptionsNonabortable): SessionRegionChange | undefined;
+/**
+ * Keep a cheap content-only path when a same-line-count pass cannot alter the
+ * canonical blocks. Gap, ambiguous, or multi-region edits rebuild statelessly.
+ */
+declare function applySessionChangedLines(diff: FileDiffMetadata, changedAdditionLineIndexes: Iterable<number>, parseDiffOptions?: CreatePatchOptionsNonabortable, previousAdditionLines?: ReadonlyMap<number, string>): SessionRegionChange | undefined;
+/** Preserve expansion at the surviving outer edges of rebuilt old-side gaps. */
+declare function remapExpandedHunksForRegionChange(expandedHunks: Map<number, HunkExpansionRegion>, change: SessionRegionChange): Map<number, HunkExpansionRegion>;
+/**
+ * An expanded gap-edge slice in old-side (deletion-line) coordinates as a
+ * `[start, end)` range. Old-side coordinates survive the exit recompute
+ * unchanged — edits only touch the new side — so these anchor best-effort
+ * expansion preservation across the recompute.
+ */
+type ExpansionAnchorRange = [start: number, end: number];
+/** Snapshot the expanded gap-edge slices before the exit recompute. */
+declare function captureExpansionAnchors(diff: FileDiffMetadata, expandedHunks: Map<number, HunkExpansionRegion>, collapsedContextThreshold: number): ExpansionAnchorRange[];
+/**
+ * Rebuild gap expansion state against the recomputed hunks: for each new
+ * gap, an anchor touching the gap's start edge restores `fromStart`, one
+ * touching its end edge restores `fromEnd`, and anchors for gaps that no
+ * longer exist drop.
+ */
+declare function rebuildExpansionFromAnchors(diff: FileDiffMetadata, anchors: ExpansionAnchorRange[]): Map<number, HunkExpansionRegion>;
+/**
+ * Genuine session exit: when session passes reshaped the hunks, run the real
+ * full recompute so exit state matches a non-session edit pipeline, and clear
+ * the marker. Returns true when a recompute ran.
+ */
+declare function finishEditSessionForDiff(diff: FileDiffMetadata, parseDiffOptions?: CreatePatchOptionsNonabortable): boolean;
+//#endregion
+export { DivergenceCore, ExpansionAnchorRange, SessionRegionChange, applySessionChangedLines, captureExpansionAnchors, findDivergenceCore, finishEditSessionForDiff, normalizeEditorLines, rebuildExpansionFromAnchors, rebuildSessionHunks, remapExpandedHunksForRegionChange };
+//# sourceMappingURL=editSessionHunks.d.ts.map

package/dist/utils/editSessionHunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editSessionHunks.d.ts","names":[],"sources":["../../src/utils/editSessionHunks.ts"],"mappings":";;;;UA6BiB,cAAA;EACf,KAAA;EACA,WAAA;EACA,WAAA;AAAA;AAAA,UAGQ,kBAAA;EACR,UAAA;EACA,SAAS;AAAA;;UAIM,mBAAA;EACf,OAAA,EAAS,KAAK,CAAC,kBAAA;AAAA;;;AALN;AAIX;;iBA4BgB,oBAAA,CAAqB,KAAe;;;;;iBAWpC,kBAAA,CACd,aAAA,YACA,aAAA,aACC,cAAc;AAzCkB;AA2BnC;;;;AA3BmC,iBAoEnB,mBAAA,CACd,IAAA,EAAM,gBAAA,EACN,gBAAA,GAAmB,8BAAA,GAClB,mBAAA;AAjCH;;;;AAAA,iBAoEgB,wBAAA,CACd,IAAA,EAAM,gBAAA,EACN,0BAAA,EAA4B,QAAA,UAC5B,gBAAA,GAAmB,8BAAA,EACnB,qBAAA,GAAwB,WAAA,mBACvB,mBAAA;;iBAwHa,iCAAA,CACd,aAAA,EAAe,GAAA,SAAY,mBAAA,GAC3B,MAAA,EAAQ,mBAAA,GACP,GAAA,SAAY,mBAAA;;AAjME;AA2BjB;;;;KAmMY,oBAAA,IAAwB,KAAA,UAAe,GAAG;;iBAGtC,uBAAA,CACd,IAAA,EAAM,gBAAA,EACN,aAAA,EAAe,GAAA,SAAY,mBAAA,GAC3B,yBAAA,WACC,oBAAA;;;;;;;iBAoDa,2BAAA,CACd,IAAA,EAAM,gBAAA,EACN,OAAA,EAAS,oBAAA,KACR,GAAA,SAAY,mBAAA;AA9PO;AAmCtB;;;;AAnCsB,iBA4SN,wBAAA,CACd,IAAA,EAAM,gBAAA,EACN,gBAAA,GAAmB,8BAA8B"}

package/dist/utils/editSessionHunks.js

@@ -0,0 +1,437 @@
+import { getHunkSideStartBoundary } from "./getHunkSideBoundaries.js";
+import { parseDiffFromFile } from "./parseDiffFromFile.js";
+import { getExpandedRegion, getTrailingExpandedRegion } from "./virtualDiffLayout.js";
+import { offsetHunkContent, preserveTrailingEditorBlankLine, recomputeDiffHunksForEdit, recomputeDiffRenderLineCounts, recomputeHunkRenderLineCounts, syncHunkNoEOFCRFromFullFile } from "./updateDiffHunks.js";
+//#region src/utils/editSessionHunks.ts
+const deletionLineSetCache = /* @__PURE__ */ new WeakMap();
+/**
+* Drops the editor document's phantom trailing empty line (a document ending
+* in a newline exposes one extra empty line the parsed diff never contains)
+* so session line arrays compare like parse-derived ones.
+*/
+function normalizeEditorLines(lines) {
+	if (lines.length > 1 && lines[lines.length - 1] === "") return lines.slice(0, -1);
+	return lines;
+}
+/**
+* Find the complete old/current divergence core. The old side is immutable
+* during an edit session, so this result needs no prior-pass snapshot.
+*/
+function findDivergenceCore(deletionLines, additionLines) {
+	const maxStart = Math.min(deletionLines.length, additionLines.length);
+	let start = 0;
+	while (start < maxStart && deletionLines[start] === additionLines[start]) start++;
+	let deletionEnd = deletionLines.length;
+	let additionEnd = additionLines.length;
+	while (deletionEnd > start && additionEnd > start && deletionLines[deletionEnd - 1] === additionLines[additionEnd - 1]) {
+		deletionEnd--;
+		additionEnd--;
+	}
+	if (start === deletionEnd && start === additionEnd) return;
+	return {
+		start,
+		deletionEnd,
+		additionEnd
+	};
+}
+/**
+* Rebuild the session skeleton as a pure function of the immutable old lines,
+* current new lines, and old-side ranges of the previous regions. One
+* canonical parse supplies the same change blocks that session exit will use.
+*/
+function rebuildSessionHunks(diff, parseDiffOptions) {
+	const previousHunks = diff.hunks;
+	const editorAdditionLines = diff.additionLines;
+	const canonicalAdditionLines = normalizeEditorLines(editorAdditionLines);
+	const canonicalDiff = canonicalAdditionLines === editorAdditionLines ? diff : {
+		...diff,
+		additionLines: canonicalAdditionLines
+	};
+	const plans = buildRegionPlans(previousHunks, parseCanonicalChangeBlocks(canonicalDiff, parseDiffOptions), diff.deletionLines.length);
+	const nextHunks = buildRegionHunks(canonicalDiff, plans);
+	diff.additionLines = canonicalAdditionLines;
+	diff.hunks = nextHunks;
+	diff.editSessionDirty = true;
+	finalizeSessionHunks(diff);
+	preserveTrailingEditorBlankLine(diff, editorAdditionLines);
+	if (!hasRegionOrSplitLayoutChanged(previousHunks, diff.hunks)) return;
+	return { regions: plans.map((plan) => plan.previousSpan) };
+}
+/**
+* Keep a cheap content-only path when a same-line-count pass cannot alter the
+* canonical blocks. Gap, ambiguous, or multi-region edits rebuild statelessly.
+*/
+function applySessionChangedLines(diff, changedAdditionLineIndexes, parseDiffOptions, previousAdditionLines) {
+	const lines = Array.from(new Set(changedAdditionLineIndexes)).filter((line) => line >= 0 && line < diff.additionLines.length).sort((a, b) => a - b);
+	if (lines.length === 0) return;
+	const { hunks } = diff;
+	let regionIndex;
+	let hunkIndex = 0;
+	for (const line of lines) {
+		while (hunkIndex < hunks.length) {
+			const hunk = hunks[hunkIndex];
+			if (line < getHunkAdditionStart(hunk) + hunk.additionCount) break;
+			hunkIndex++;
+		}
+		const hunk = hunks[hunkIndex];
+		const start = hunk == null ? void 0 : getHunkAdditionStart(hunk);
+		if (start == null || line < start || regionIndex != null && regionIndex !== hunkIndex) return rebuildSessionHunks(diff, parseDiffOptions);
+		regionIndex = hunkIndex;
+	}
+	if (regionIndex == null) return;
+	if (canRetainCanonicalBlocks(diff, lines, regionIndex, previousAdditionLines, parseDiffOptions)) {
+		diff.editSessionDirty = true;
+		return;
+	}
+	return rebuildSessionHunks(diff, parseDiffOptions);
+}
+function canRetainCanonicalBlocks(diff, changedLines, regionIndex, previousAdditionLines, parseDiffOptions) {
+	if (previousAdditionLines == null || parseDiffOptions?.ignoreWhitespace === true || parseDiffOptions?.stripTrailingCr === true) return false;
+	const deletionLineSet = getDeletionLineSet(diff);
+	const hunk = diff.hunks[regionIndex];
+	if (hunk.hunkContent.some(isPureChange)) return false;
+	for (const line of changedLines) {
+		const previousLine = previousAdditionLines.get(line);
+		const additionLine = diff.additionLines[line];
+		if (previousLine == null || additionLine == null || deletionLineSet.has(previousLine) || deletionLineSet.has(additionLine)) return false;
+		let insideBalancedChange = false;
+		for (const content of hunk.hunkContent) if (content.type === "change" && content.additions === content.deletions && line >= content.additionLineIndex && line < content.additionLineIndex + content.additions) {
+			insideBalancedChange = true;
+			break;
+		}
+		if (!insideBalancedChange) return false;
+	}
+	return true;
+}
+function getDeletionLineSet(diff) {
+	const cached = deletionLineSetCache.get(diff);
+	if (cached?.lines === diff.deletionLines) return cached.set;
+	const set = new Set(diff.deletionLines);
+	deletionLineSetCache.set(diff, {
+		lines: diff.deletionLines,
+		set
+	});
+	return set;
+}
+function isPureChange(content) {
+	return content?.type === "change" && (content.additions === 0 || content.deletions === 0);
+}
+/** Preserve expansion at the surviving outer edges of rebuilt old-side gaps. */
+function remapExpandedHunksForRegionChange(expandedHunks, change) {
+	const remapped = /* @__PURE__ */ new Map();
+	const { regions } = change;
+	for (let key = 0; key <= regions.length; key++) {
+		const previous = regions[key - 1];
+		const next = regions[key];
+		const fromStartSource = key === 0 ? expandedHunks.get(0) : previous == null ? void 0 : expandedHunks.get(previous.lastIndex + 1);
+		const fromEndSource = next == null ? void 0 : expandedHunks.get(next.firstIndex);
+		const fromStart = fromStartSource?.fromStart ?? 0;
+		const fromEnd = fromEndSource?.fromEnd ?? 0;
+		if (fromStart > 0 || fromEnd > 0) remapped.set(key, {
+			fromStart,
+			fromEnd
+		});
+	}
+	return remapped;
+}
+/** Snapshot the expanded gap-edge slices before the exit recompute. */
+function captureExpansionAnchors(diff, expandedHunks, collapsedContextThreshold) {
+	const anchors = [];
+	if (diff.isPartial) return anchors;
+	for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+		const region = getExpandedRegion({
+			isPartial: diff.isPartial,
+			rangeSize: hunk.collapsedBefore,
+			expandedHunks,
+			hunkIndex,
+			collapsedContextThreshold
+		});
+		if (region.rangeSize <= collapsedContextThreshold) continue;
+		const gapEnd = getHunkDeletionStart(hunk);
+		const gapStart = gapEnd - region.rangeSize;
+		if (region.fromStart > 0) anchors.push([gapStart, gapStart + region.fromStart]);
+		if (region.fromEnd > 0) anchors.push([gapEnd - region.fromEnd, gapEnd]);
+	}
+	const trailingRegion = getTrailingExpandedRegion({
+		fileDiff: diff,
+		hunkIndex: diff.hunks.length - 1,
+		expandedHunks,
+		collapsedContextThreshold,
+		errorPrefix: "captureExpansionAnchors"
+	});
+	if (trailingRegion != null && trailingRegion.fromStart > 0 && trailingRegion.rangeSize > collapsedContextThreshold) {
+		const lastHunk = diff.hunks[diff.hunks.length - 1];
+		const gapStart = getHunkDeletionStart(lastHunk) + lastHunk.deletionCount;
+		anchors.push([gapStart, gapStart + trailingRegion.fromStart]);
+	}
+	return anchors;
+}
+/**
+* Rebuild gap expansion state against the recomputed hunks: for each new
+* gap, an anchor touching the gap's start edge restores `fromStart`, one
+* touching its end edge restores `fromEnd`, and anchors for gaps that no
+* longer exist drop.
+*/
+function rebuildExpansionFromAnchors(diff, anchors) {
+	const rebuilt = /* @__PURE__ */ new Map();
+	if (anchors.length === 0) return rebuilt;
+	const applyGap = (key, gapStart, gapEnd) => {
+		if (gapEnd <= gapStart) return;
+		let fromStart = 0;
+		let fromEnd = 0;
+		for (const [start, end] of anchors) {
+			if (end <= gapStart || start >= gapEnd) continue;
+			if (start <= gapStart) fromStart = Math.max(fromStart, Math.min(end, gapEnd) - gapStart);
+			if (end >= gapEnd) fromEnd = Math.max(fromEnd, gapEnd - Math.max(start, gapStart));
+		}
+		if (fromStart > 0 || fromEnd > 0) rebuilt.set(key, {
+			fromStart,
+			fromEnd
+		});
+	};
+	for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+		const gapEnd = getHunkDeletionStart(hunk);
+		applyGap(hunkIndex, gapEnd - Math.max(hunk.collapsedBefore, 0), gapEnd);
+	}
+	const lastHunk = diff.hunks[diff.hunks.length - 1];
+	if (lastHunk != null && !diff.isPartial && diff.deletionLines.length > 0) applyGap(diff.hunks.length, getHunkDeletionStart(lastHunk) + lastHunk.deletionCount, diff.deletionLines.length);
+	return rebuilt;
+}
+/**
+* Genuine session exit: when session passes reshaped the hunks, run the real
+* full recompute so exit state matches a non-session edit pipeline, and clear
+* the marker. Returns true when a recompute ran.
+*/
+function finishEditSessionForDiff(diff, parseDiffOptions) {
+	if (diff.editSessionDirty !== true) return false;
+	diff.editSessionDirty = void 0;
+	Object.assign(diff, recomputeDiffHunksForEdit(diff, parseDiffOptions));
+	return true;
+}
+function parseCanonicalChangeBlocks(diff, parseDiffOptions) {
+	if (findDivergenceCore(diff.deletionLines, diff.additionLines) == null) return [];
+	const parsed = parseDiffFromFile({
+		name: diff.prevName ?? diff.name,
+		contents: diff.deletionLines.join("")
+	}, {
+		name: diff.name,
+		contents: diff.additionLines.join(""),
+		lang: diff.lang
+	}, parseDiffOptions);
+	const blocks = [];
+	let coveredAdditions = 0;
+	let coveredDeletions = 0;
+	for (const hunk of parsed.hunks) {
+		const contextLines = hunk.additionCount > 0 ? hunk.additionLineIndex - coveredAdditions : hunk.deletionLineIndex - coveredDeletions;
+		coveredAdditions += contextLines;
+		coveredDeletions += contextLines;
+		for (const content of hunk.hunkContent) {
+			if (content.type === "context") {
+				coveredAdditions += content.lines;
+				coveredDeletions += content.lines;
+				continue;
+			}
+			const block = offsetHunkContent(content, 0, 0);
+			if (block.additions === 0) block.additionLineIndex = coveredAdditions;
+			if (block.deletions === 0) block.deletionLineIndex = coveredDeletions;
+			blocks.push(block);
+			coveredAdditions += block.additions;
+			coveredDeletions += block.deletions;
+		}
+	}
+	return blocks;
+}
+function buildRegionPlans(previousHunks, blocks, deletionLineCount) {
+	const previousPlans = previousHunks.map((hunk, index) => {
+		const deletionStart = getHunkDeletionStart(hunk);
+		return {
+			deletionStart,
+			deletionEnd: deletionStart + hunk.deletionCount,
+			blocks: [],
+			previousSpan: {
+				firstIndex: index,
+				lastIndex: index
+			}
+		};
+	});
+	const plans = [];
+	let previousIndex = 0;
+	for (const block of blocks) {
+		const blockStart = block.deletionLineIndex;
+		const blockEnd = blockStart + block.deletions;
+		while (previousIndex < previousPlans.length && previousPlans[previousIndex].deletionEnd < blockStart) {
+			plans.push(previousPlans[previousIndex]);
+			previousIndex++;
+		}
+		let plan = plans.length > 0 && blockTouchesRegion(blockStart, blockEnd, plans[plans.length - 1]) ? plans.pop() : void 0;
+		while (previousIndex < previousPlans.length && previousPlans[previousIndex].deletionStart <= blockEnd) {
+			plan = mergeRegionPlans(plan, previousPlans[previousIndex]);
+			previousIndex++;
+		}
+		if (plan == null) {
+			let deletionStart = blockStart;
+			let deletionEnd = blockEnd;
+			if ((block.deletions === 0 || block.additions === 0) && deletionLineCount > block.deletions) {
+				const previousEnd = plans[plans.length - 1]?.deletionEnd ?? 0;
+				const nextStart = previousPlans[previousIndex]?.deletionStart ?? deletionLineCount;
+				if (blockStart > previousEnd) deletionStart--;
+				else if (blockEnd < nextStart) deletionEnd++;
+			}
+			plan = {
+				deletionStart,
+				deletionEnd,
+				blocks: [],
+				previousSpan: void 0
+			};
+		}
+		plan.deletionStart = Math.min(plan.deletionStart, blockStart);
+		plan.deletionEnd = Math.max(plan.deletionEnd, blockEnd);
+		plan.blocks.push(block);
+		plans.push(plan);
+	}
+	while (previousIndex < previousPlans.length) {
+		plans.push(previousPlans[previousIndex]);
+		previousIndex++;
+	}
+	return plans;
+}
+function blockTouchesRegion(blockStart, blockEnd, region) {
+	return blockStart <= region.deletionEnd && blockEnd >= region.deletionStart;
+}
+function mergeRegionPlans(target, source) {
+	if (target == null) return source;
+	target.deletionStart = Math.min(target.deletionStart, source.deletionStart);
+	target.deletionEnd = Math.max(target.deletionEnd, source.deletionEnd);
+	target.blocks.push(...source.blocks);
+	if (source.previousSpan != null) {
+		target.previousSpan ??= { ...source.previousSpan };
+		target.previousSpan.firstIndex = Math.min(target.previousSpan.firstIndex, source.previousSpan.firstIndex);
+		target.previousSpan.lastIndex = Math.max(target.previousSpan.lastIndex, source.previousSpan.lastIndex);
+	}
+	return target;
+}
+function buildRegionHunks(diff, plans) {
+	const hunks = [];
+	let deletionCursor = 0;
+	let additionCursor = 0;
+	for (const plan of plans) {
+		const contextBefore = plan.deletionStart - deletionCursor;
+		if (contextBefore < 0) throw new Error("buildRegionHunks: overlapping old-side regions");
+		deletionCursor += contextBefore;
+		additionCursor += contextBefore;
+		const additionStart = additionCursor;
+		const hunkContent = [];
+		for (const canonicalBlock of plan.blocks) {
+			const deletionContext = canonicalBlock.deletionLineIndex - deletionCursor;
+			const additionContext = canonicalBlock.additionLineIndex - additionCursor;
+			if (deletionContext < 0 || deletionContext !== additionContext) throw new Error("buildRegionHunks: canonical block context mismatch");
+			pushContext(hunkContent, deletionContext, additionCursor, deletionCursor);
+			deletionCursor += deletionContext;
+			additionCursor += additionContext;
+			hunkContent.push({ ...canonicalBlock });
+			deletionCursor += canonicalBlock.deletions;
+			additionCursor += canonicalBlock.additions;
+		}
+		const trailingContext = plan.deletionEnd - deletionCursor;
+		if (trailingContext < 0) throw new Error("buildRegionHunks: block exceeds its old-side region");
+		pushContext(hunkContent, trailingContext, additionCursor, deletionCursor);
+		deletionCursor += trailingContext;
+		additionCursor += trailingContext;
+		hunks.push(createRegionHunk(diff, {
+			additionStart,
+			additionEnd: additionCursor,
+			deletionStart: plan.deletionStart,
+			deletionEnd: plan.deletionEnd
+		}, hunkContent));
+	}
+	if (diff.deletionLines.length - deletionCursor !== diff.additionLines.length - additionCursor) throw new Error("buildRegionHunks: trailing context mismatch");
+	return hunks;
+}
+function createRegionHunk(diff, bounds, hunkContent) {
+	const additionCount = bounds.additionEnd - bounds.additionStart;
+	const deletionCount = bounds.deletionEnd - bounds.deletionStart;
+	let additionLines = 0;
+	let deletionLines = 0;
+	for (const content of hunkContent) if (content.type === "change") {
+		additionLines += content.additions;
+		deletionLines += content.deletions;
+	}
+	const hunk = {
+		collapsedBefore: 0,
+		additionStart: getUnifiedStart(bounds.additionStart, additionCount),
+		additionCount,
+		additionLines,
+		additionLineIndex: getUnifiedLineIndex(bounds.additionStart, additionCount),
+		deletionStart: getUnifiedStart(bounds.deletionStart, deletionCount),
+		deletionCount,
+		deletionLines,
+		deletionLineIndex: getUnifiedLineIndex(bounds.deletionStart, deletionCount),
+		hunkContent,
+		hunkSpecs: `@@ -${getUnifiedStart(bounds.deletionStart, deletionCount)},${deletionCount} +${getUnifiedStart(bounds.additionStart, additionCount)},${additionCount} @@`,
+		splitLineStart: 0,
+		splitLineCount: 0,
+		unifiedLineStart: 0,
+		unifiedLineCount: 0,
+		noEOFCRAdditions: false,
+		noEOFCRDeletions: false
+	};
+	recomputeHunkRenderLineCounts(hunk);
+	return hunk;
+}
+function pushContext(hunkContent, lines, additionLineIndex, deletionLineIndex) {
+	if (lines > 0) hunkContent.push({
+		type: "context",
+		lines,
+		additionLineIndex,
+		deletionLineIndex
+	});
+}
+function hasRegionOrSplitLayoutChanged(previous, next) {
+	if (previous.length !== next.length) return true;
+	for (let index = 0; index < previous.length; index++) {
+		const previousHunk = previous[index];
+		const nextHunk = next[index];
+		if (getHunkDeletionStart(previousHunk) !== getHunkDeletionStart(nextHunk) || previousHunk.deletionCount !== nextHunk.deletionCount || getHunkAdditionStart(previousHunk) !== getHunkAdditionStart(nextHunk) || previousHunk.additionCount !== nextHunk.additionCount || previousHunk.splitLineCount !== nextHunk.splitLineCount || !haveSameSplitRowMapping(previousHunk, nextHunk)) return true;
+	}
+	return false;
+}
+function haveSameSplitRowMapping(previous, next) {
+	const previousRows = iterateSplitRowMapping(previous);
+	const nextRows = iterateSplitRowMapping(next);
+	while (true) {
+		const previousRow = previousRows.next();
+		const nextRow = nextRows.next();
+		if (previousRow.done === true || nextRow.done === true) return previousRow.done === nextRow.done;
+		if (previousRow.value[0] !== nextRow.value[0] || previousRow.value[1] !== nextRow.value[1]) return false;
+	}
+}
+function* iterateSplitRowMapping(hunk) {
+	for (const content of hunk.hunkContent) {
+		if (content.type === "context") {
+			for (let offset = 0; offset < content.lines; offset++) yield [content.deletionLineIndex + offset, content.additionLineIndex + offset];
+			continue;
+		}
+		const rowCount = Math.max(content.deletions, content.additions);
+		for (let offset = 0; offset < rowCount; offset++) yield [offset < content.deletions ? content.deletionLineIndex + offset : void 0, offset < content.additions ? content.additionLineIndex + offset : void 0];
+	}
+}
+function getHunkAdditionStart(hunk) {
+	return getHunkSideStartBoundary(hunk.additionStart, hunk.additionCount);
+}
+function getHunkDeletionStart(hunk) {
+	return getHunkSideStartBoundary(hunk.deletionStart, hunk.deletionCount);
+}
+function getUnifiedStart(lineIndex, count) {
+	return count === 0 ? lineIndex : lineIndex + 1;
+}
+function getUnifiedLineIndex(lineIndex, count) {
+	return count === 0 ? lineIndex - 1 : lineIndex;
+}
+function finalizeSessionHunks(diff) {
+	recomputeDiffRenderLineCounts(diff);
+	for (let index = 0; index < diff.hunks.length; index++) syncHunkNoEOFCRFromFullFile(diff, index);
+}
+//#endregion
+export { applySessionChangedLines, captureExpansionAnchors, findDivergenceCore, finishEditSessionForDiff, normalizeEditorLines, rebuildExpansionFromAnchors, rebuildSessionHunks, remapExpandedHunksForRegionChange };
+
+//# sourceMappingURL=editSessionHunks.js.map