@pierre/diffs 1.1.20 → 1.2.0-beta.0

package/dist/worker/worker-portable.js

@@ -9270,7 +9270,7 @@ function l(a$1) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/regex@6.0.1/node_modules/regex/src/utils-internals.js
+//#region ../../node_modules/.bun/regex@6.1.0/node_modules/regex/src/utils-internals.js
 const noncapturingDelim = String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;
 /**
 Updates the array in place by incrementing each value greater than or equal to the threshold.
@@ -9458,13 +9458,16 @@ function getGroupContents(expression, contentsStartPos) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/regex@6.0.1/node_modules/regex/src/atomic.js
+//#region ../../node_modules/.bun/regex@6.1.0/node_modules/regex/src/atomic.js
+/**
+@import {PluginData, PluginResult} from './regex.js';
+*/
 const atomicPluginToken = new RegExp(String.raw`(?<noncapturingStart>${noncapturingDelim})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`, "gsu");
 /**
 Apply transformations for atomic groups: `(?>…)`.
 @param {string} expression
-@param {import('./regex.js').PluginData} [data]
-@returns {Required<import('./regex.js').PluginResult>}
+@param {PluginData} [data]
+@returns {Required<PluginResult>}
 */
 function atomic(expression, data) {
 	const hiddenCaptures = data?.hiddenCaptures ?? [];
@@ -9572,7 +9575,7 @@ Transform posessive quantifiers into atomic groups. The posessessive quantifiers
 This follows Java, PCRE, Perl, and Python.
 Possessive quantifiers in Oniguruma and Onigmo are only: `?+`, `*+`, `++`.
 @param {string} expression
-@returns {import('./regex.js').PluginResult}
+@returns {PluginResult}
 */
 function possessive(expression) {
 	if (!new RegExp(`${baseQuantifier}\\+`).test(expression)) {
@@ -9631,7 +9634,7 @@ function possessive(expression) {
 }
 
 //#endregion
-//#region ../../node_modules/.bun/regex@6.0.1/node_modules/regex/src/subclass.js
+//#region ../../node_modules/.bun/regex@6.1.0/node_modules/regex/src/subclass.js
 /**
 Works the same as JavaScript's native `RegExp` constructor in all contexts, but automatically
 adjusts subpattern matches and indices (with flag `d`) to account for captures added as part of
@@ -12159,12 +12162,27 @@ const THEME_CSS_ATTRIBUTE = "data-theme-css";
 const UNSAFE_CSS_ATTRIBUTE = "data-unsafe-css";
 const CORE_CSS_ATTRIBUTE = "data-core-css";
 const DEFAULT_COLLAPSED_CONTEXT_THRESHOLD = 1;
+const DEFAULT_TOKENIZE_MAX_LENGTH = 1e5;
 const DEFAULT_VIRTUAL_FILE_METRICS = {
 	hunkLineCount: 50,
 	lineHeight: 20,
 	diffHeaderHeight: 44,
 	hunkSeparatorHeight: 32,
-	fileGap: 8
+	spacing: 8
+};
+const DEFAULT_CODE_VIEW_FILE_METRICS = {
+	...DEFAULT_VIRTUAL_FILE_METRICS,
+	hunkLineCount: 1
+};
+const DEFAULT_CODE_VIEW_METRICS = {
+	paddingTop: 8,
+	paddingBottom: 8,
+	gap: 8
+};
+const DEFAULT_SMOOTH_SCROLL_SETTINGS = {
+	omega: .015,
+	positionEpsilon: .5,
+	velocityEpsilon: .05
 };
 const DEFAULT_EXPANDED_REGION = Object.freeze({
 	fromStart: 0,
@@ -15069,13 +15087,20 @@ function getLineNodes(nodes) {
 //#endregion
 //#region src/utils/iterateOverDiff.ts
 function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infinity, expandedHunks, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, callback }) {
+	const iterationStart = getIterationStartState({
+		diff,
+		diffStyle,
+		startingLine,
+		expandedHunks,
+		collapsedContextThreshold
+	});
 	const state = {
 		finalHunk: diff.hunks.at(-1),
 		viewportStart: startingLine,
 		viewportEnd: startingLine + totalLines,
 		isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
-		splitCount: 0,
-		unifiedCount: 0,
+		splitCount: iterationStart.splitCount,
+		unifiedCount: iterationStart.unifiedCount,
 		shouldBreak() {
 			if (!state.isWindowedHighlight) {
 				return false;
@@ -15145,7 +15170,11 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			return callback(props) ?? false;
 		}
 	};
-	hunkIterator: for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+	hunkIterator: for (let hunkIndex = iterationStart.hunkIndex; hunkIndex < diff.hunks.length; hunkIndex++) {
+		const hunk = diff.hunks[hunkIndex];
+		if (hunk == null) {
+			throw new Error("iterateOverDiff: invalid hunk index");
+		}
 		if (state.shouldBreak()) {
 			break;
 		}
@@ -15187,8 +15216,16 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			let additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.rangeSize;
 			let deletionLineNumber$1 = hunk.deletionStart - leadingRegion.rangeSize;
 			let additionLineNumber$1 = hunk.additionStart - leadingRegion.rangeSize;
-			let index = 0;
+			const [startIndex, endIndex] = getEqualLineIterationRange(state, leadingRegion.fromStart, diffStyle);
+			if (startIndex > 0) {
+				state.incrementCounts(startIndex, startIndex);
+			}
+			let index = startIndex;
 			while (index < leadingRegion.fromStart) {
+				if (index >= endIndex) {
+					state.incrementCounts(leadingRegion.fromStart - index, leadingRegion.fromStart - index);
+					break;
+				}
 				if (state.isInWindow(0, 0)) {
 					if (state.emit({
 						hunkIndex,
@@ -15224,8 +15261,16 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.fromEnd;
 			deletionLineNumber$1 = hunk.deletionStart - leadingRegion.fromEnd;
 			additionLineNumber$1 = hunk.additionStart - leadingRegion.fromEnd;
-			index = 0;
+			const [fromEndStartIndex, fromEndEndIndex] = getEqualLineIterationRange(state, leadingRegion.fromEnd, diffStyle);
+			if (fromEndStartIndex > 0) {
+				state.incrementCounts(fromEndStartIndex, fromEndStartIndex);
+			}
+			index = fromEndStartIndex;
 			while (index < leadingRegion.fromEnd) {
+				if (index >= fromEndEndIndex) {
+					state.incrementCounts(leadingRegion.fromEnd - index, leadingRegion.fromEnd - index);
+					break;
+				}
 				if (state.isInWindow(0, 0)) {
 					if (state.emit({
 						hunkIndex,
@@ -15273,8 +15318,16 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			const isLastContent = content === lastContent;
 			if (content.type === "context") {
 				if (!state.shouldSkip(content.lines, content.lines)) {
-					let index = 0;
+					const [startIndex, endIndex] = getEqualLineIterationRange(state, content.lines, diffStyle);
+					if (startIndex > 0) {
+						state.incrementCounts(startIndex, startIndex);
+					}
+					let index = startIndex;
 					while (index < content.lines) {
+						if (index >= endIndex) {
+							state.incrementCounts(content.lines - index, content.lines - index);
+							break;
+						}
 						if (state.isInWindow(0, 0)) {
 							const isLastLine = isLastContent && index === content.lines - 1;
 							const unifiedRowIndex = unifiedLineIndex + index;
@@ -15364,11 +15417,19 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		if (trailingRegion != null) {
 			const { collapsedLines, fromStart, fromEnd } = trailingRegion;
 			const len = fromStart + fromEnd;
-			let index = 0;
+			const [startIndex, endIndex] = getEqualLineIterationRange(state, len, diffStyle);
+			if (startIndex > 0) {
+				state.incrementCounts(startIndex, startIndex);
+			}
+			let index = startIndex;
 			while (index < len) {
 				if (state.shouldBreak()) {
 					break hunkIterator;
 				}
+				if (index >= endIndex) {
+					state.incrementCounts(len - index, len - index);
+					break;
+				}
 				if (state.isInWindow(0, 0)) {
 					const isLastLine = index === len - 1;
 					if (state.emit({
@@ -15402,6 +15463,126 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		}
 	}
 }
+function getIterationStartState({ diff, diffStyle, startingLine, expandedHunks, collapsedContextThreshold }) {
+	if (startingLine <= 0 || diffStyle === "both") {
+		return {
+			hunkIndex: 0,
+			splitCount: 0,
+			unifiedCount: 0
+		};
+	}
+	const prefixCounts = getHunkPrefixCounts({
+		diff,
+		expandedHunks,
+		collapsedContextThreshold
+	});
+	let low = 0;
+	let high = diff.hunks.length - 1;
+	let result = diff.hunks.length;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const counts$1 = prefixCounts[mid + 1];
+		if (counts$1 == null) {
+			throw new Error("iterateOverDiff: invalid hunk prefix index");
+		}
+		const selectedCount = diffStyle === "unified" ? counts$1.unifiedCount : counts$1.splitCount;
+		if (selectedCount > startingLine) {
+			result = mid;
+			high = mid - 1;
+		} else {
+			low = mid + 1;
+		}
+	}
+	if (result >= diff.hunks.length) {
+		const counts$1 = prefixCounts[diff.hunks.length];
+		if (counts$1 == null) {
+			throw new Error("iterateOverDiff: invalid terminal hunk prefix index");
+		}
+		return {
+			hunkIndex: diff.hunks.length,
+			splitCount: counts$1.splitCount,
+			unifiedCount: counts$1.unifiedCount
+		};
+	}
+	const counts = prefixCounts[result];
+	if (counts == null) {
+		throw new Error("iterateOverDiff: invalid selected hunk prefix index");
+	}
+	return {
+		hunkIndex: result,
+		splitCount: counts.splitCount,
+		unifiedCount: counts.unifiedCount
+	};
+}
+function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold }) {
+	let splitCount = 0;
+	let unifiedCount = 0;
+	const finalHunkIndex = diff.hunks.length - 1;
+	const prefixCounts = [{
+		splitCount: 0,
+		unifiedCount: 0
+	}];
+	for (let index = 0; index < diff.hunks.length; index++) {
+		const hunk = diff.hunks[index];
+		if (hunk == null) {
+			throw new Error("iterateOverDiff: invalid hunk summary index");
+		}
+		const leadingRegion = getExpandedRegion(diff.isPartial, hunk.collapsedBefore, expandedHunks, index, collapsedContextThreshold);
+		const leadingCount = leadingRegion.fromStart + leadingRegion.fromEnd;
+		splitCount += leadingCount + hunk.splitLineCount;
+		unifiedCount += leadingCount + hunk.unifiedLineCount;
+		if (index === finalHunkIndex && hasFinalCollapsedHunk(diff)) {
+			const trailingRangeSize = getTrailingRangeSize(diff, hunk);
+			const trailingRegion = getExpandedRegion(diff.isPartial, trailingRangeSize, expandedHunks, diff.hunks.length, collapsedContextThreshold);
+			const trailingCount = trailingRegion.fromStart + trailingRegion.fromEnd;
+			splitCount += trailingCount;
+			unifiedCount += trailingCount;
+		}
+		prefixCounts.push({
+			splitCount,
+			unifiedCount
+		});
+	}
+	return prefixCounts;
+}
+function getEqualLineIterationRange(state, count, diffStyle) {
+	if (!state.isWindowedHighlight || count <= 0) {
+		return [0, count];
+	}
+	const ranges = [];
+	function pushRange(currentCount) {
+		const start$1 = Math.max(0, state.viewportStart - currentCount);
+		const end$1 = Math.min(count, state.viewportEnd - currentCount);
+		if (end$1 > start$1) {
+			ranges.push([start$1, end$1]);
+		}
+	}
+	if (diffStyle !== "split") {
+		pushRange(state.unifiedCount);
+	}
+	if (diffStyle !== "unified") {
+		pushRange(state.splitCount);
+	}
+	if (ranges.length === 0) {
+		return [0, 0];
+	}
+	let start = ranges[0][0];
+	let end = ranges[0][1];
+	for (let index = 1; index < ranges.length; index++) {
+		const range$1 = ranges[index];
+		start = Math.min(start, range$1[0]);
+		end = Math.max(end, range$1[1]);
+	}
+	return [start, end];
+}
+function getTrailingRangeSize(diff, hunk) {
+	const additionRemaining = diff.additionLines.length - (hunk.additionLineIndex + hunk.additionCount);
+	const deletionRemaining = diff.deletionLines.length - (hunk.deletionLineIndex + hunk.deletionCount);
+	if (additionRemaining !== deletionRemaining) {
+		throw new Error(`iterateOverDiff: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${diff.name}`);
+	}
+	return Math.min(additionRemaining, deletionRemaining);
+}
 function getExpandedRegion(isPartial, rangeSize, expandedHunks, hunkIndex, collapsedContextThreshold) {
 	rangeSize = Math.max(rangeSize, 0);
 	if (rangeSize === 0 || isPartial) {