@davmash/bygone 0.8.11 → 0.8.13

package/out/standalone-main.js

@@ -4077,16 +4077,41 @@ var require_changeTour = __commonJS({
       }
       validateMultiPanelFiles(value.files, panels.length, index);
       validateMultiPanelSteps(value.steps, panels.length, index, true);
-      if (Array.isArray(value.steps) && value.steps.length !== panels.length - 1) {
-        throw new Error(`scenes[${index}].steps must match the number of explanation stages.`);
-      }
       if (Array.isArray(value.steps)) {
+        let previousPairIndex = -1;
         value.steps.forEach((step, stepIndex) => {
-          const panel = panels[stepIndex + 1];
-          if (!isRecord2(step) || !isRecord2(panel) || panel.stageId !== step.id) {
-            throw new Error(`scenes[${index}].panels must align with explanation stage ids.`);
+          if (!isRecord2(step)) return;
+          const pairIndex = Number(step.pairIndex);
+          if (pairIndex < previousPairIndex) {
+            throw new Error(`scenes[${index}].steps must remain grouped in explanation stage order.`);
+          }
+          previousPairIndex = pairIndex;
+          if (step.stageId !== void 0) requireString(step.stageId, `scenes[${index}].steps[${stepIndex}].stageId`);
+          if (step.stageIndex !== void 0) requireNonNegativeInteger(step.stageIndex, `scenes[${index}].steps[${stepIndex}].stageIndex`);
+          if (step.focusIndex !== void 0) requireNonNegativeInteger(step.focusIndex, `scenes[${index}].steps[${stepIndex}].focusIndex`);
+          if (step.focusCount !== void 0) requirePositiveInteger(step.focusCount, `scenes[${index}].steps[${stepIndex}].focusCount`);
+          if (step.stageIndex !== void 0 && Number(step.stageIndex) !== pairIndex) {
+            throw new Error(`scenes[${index}].steps[${stepIndex}].stageIndex must match pairIndex.`);
+          }
+          if (step.focusIndex !== void 0 && step.focusCount !== void 0 && Number(step.focusIndex) >= Number(step.focusCount)) {
+            throw new Error(`scenes[${index}].steps[${stepIndex}].focusIndex must be less than focusCount.`);
           }
         });
+        for (let stageIndex = 0; stageIndex < panels.length - 1; stageIndex += 1) {
+          const panel = panels[stageIndex + 1];
+          const stageSteps = value.steps.filter((step) => isRecord2(step) && Number(step.pairIndex) === stageIndex);
+          if (!isRecord2(panel) || stageSteps.length === 0) {
+            throw new Error(`scenes[${index}].steps must cover every explanation stage.`);
+          }
+          const firstStep = stageSteps[0];
+          const fallbackStageId = isRecord2(firstStep) ? firstStep.id : void 0;
+          if (stageSteps.some((step) => {
+            if (!isRecord2(step)) return true;
+            return (step.stageId ?? fallbackStageId) !== panel.stageId;
+          })) {
+            throw new Error(`scenes[${index}].panels must align with explanation stage ids.`);
+          }
+        }
       }
     }
     function validateMultiPanelFiles(value, panelCount, index) {
@@ -4115,7 +4140,6 @@ var require_changeTour = __commonJS({
         if (deconstructed) {
           requireStringArray(step.introducedHunks, `scenes[${index}].steps[${stepIndex}].introducedHunks`);
           if (step.introducedHunks.length === 0) throw new Error(`scenes[${index}].steps[${stepIndex}].introducedHunks must be non-empty.`);
-          if (Number(step.pairIndex) !== stepIndex) throw new Error(`scenes[${index}].steps[${stepIndex}].pairIndex must match its explanation stage.`);
         }
         if (step.side !== "left" && step.side !== "right") throw new Error(`scenes[${index}].steps[${stepIndex}].side must be left or right.`);
         if (step.startLine !== void 0) requirePositiveInteger(step.startLine, `scenes[${index}].steps[${stepIndex}].startLine`);
@@ -4755,6 +4779,7 @@ var require_changeTour = __commonJS({
       for (const { stage, claims } of stageClaims) {
         const introducedHunks = [];
         const introducedFiles = [];
+        const introducedChanges = [];
         for (const claim of claims) {
           const cumulative = cumulativeByFile.get(claim.file) || /* @__PURE__ */ new Set();
           claim.ids.forEach((id) => {
@@ -4763,6 +4788,12 @@ var require_changeTour = __commonJS({
           });
           cumulativeByFile.set(claim.file, cumulative);
           if (!introducedFiles.includes(claim.file.path)) introducedFiles.push(claim.file.path);
+          const introducedChange = introducedChanges.find((change) => change.file === claim.file.path);
+          if (introducedChange) {
+            introducedChange.hunks.push(...claim.ids);
+          } else {
+            introducedChanges.push({ file: claim.file.path, hunks: [...claim.ids] });
+          }
         }
         stages.push({
           id: stage.id,
@@ -4770,6 +4801,7 @@ var require_changeTour = __commonJS({
           narration: stage.narration,
           introducedHunks,
           introducedFiles,
+          introducedChanges,
           cumulativeHunks: [...cumulativeByFile.values()].flatMap((ids) => [...ids]),
           files: materializableFiles.map((file) => buildFileState(
             file,
@@ -4834,6 +4866,1195 @@ var require_changeTour = __commonJS({
         appliedHunks: [...selected]
       };
     }
+    function Diff2() {
+    }
+    Diff2.prototype = {
+      diff: function diff2(oldString, newString) {
+        var _options$timeout;
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        var callback = options.callback;
+        if (typeof options === "function") {
+          callback = options;
+          options = {};
+        }
+        this.options = options;
+        var self2 = this;
+        function done(value) {
+          if (callback) {
+            setTimeout(function() {
+              callback(void 0, value);
+            }, 0);
+            return true;
+          } else {
+            return value;
+          }
+        }
+        oldString = this.castInput(oldString);
+        newString = this.castInput(newString);
+        oldString = this.removeEmpty(this.tokenize(oldString));
+        newString = this.removeEmpty(this.tokenize(newString));
+        var newLen = newString.length, oldLen = oldString.length;
+        var editLength = 1;
+        var maxEditLength = newLen + oldLen;
+        if (options.maxEditLength) {
+          maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+        }
+        var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
+        var abortAfterTimestamp = Date.now() + maxExecutionTime;
+        var bestPath = [{
+          oldPos: -1,
+          lastComponent: void 0
+        }];
+        var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done([{
+            value: this.join(newString),
+            count: newString.length
+          }]);
+        }
+        var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+        function execEditLength() {
+          for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+            var basePath = void 0;
+            var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+            if (removePath) {
+              bestPath[diagonalPath - 1] = void 0;
+            }
+            var canAdd = false;
+            if (addPath) {
+              var addPathNewPos = addPath.oldPos - diagonalPath;
+              canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+            }
+            var canRemove = removePath && removePath.oldPos + 1 < oldLen;
+            if (!canAdd && !canRemove) {
+              bestPath[diagonalPath] = void 0;
+              continue;
+            }
+            if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {
+              basePath = self2.addToPath(addPath, true, void 0, 0);
+            } else {
+              basePath = self2.addToPath(removePath, void 0, true, 1);
+            }
+            newPos = self2.extractCommon(basePath, newString, oldString, diagonalPath);
+            if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+              return done(buildValues2(self2, basePath.lastComponent, newString, oldString, self2.useLongestToken));
+            } else {
+              bestPath[diagonalPath] = basePath;
+              if (basePath.oldPos + 1 >= oldLen) {
+                maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+              }
+              if (newPos + 1 >= newLen) {
+                minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+              }
+            }
+          }
+          editLength++;
+        }
+        if (callback) {
+          (function exec() {
+            setTimeout(function() {
+              if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+                return callback();
+              }
+              if (!execEditLength()) {
+                exec();
+              }
+            }, 0);
+          })();
+        } else {
+          while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+            var ret = execEditLength();
+            if (ret) {
+              return ret;
+            }
+          }
+        }
+      },
+      addToPath: function addToPath2(path9, added, removed, oldPosInc) {
+        var last = path9.lastComponent;
+        if (last && last.added === added && last.removed === removed) {
+          return {
+            oldPos: path9.oldPos + oldPosInc,
+            lastComponent: {
+              count: last.count + 1,
+              added,
+              removed,
+              previousComponent: last.previousComponent
+            }
+          };
+        } else {
+          return {
+            oldPos: path9.oldPos + oldPosInc,
+            lastComponent: {
+              count: 1,
+              added,
+              removed,
+              previousComponent: last
+            }
+          };
+        }
+      },
+      extractCommon: function extractCommon2(basePath, newString, oldString, diagonalPath) {
+        var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+          newPos++;
+          oldPos++;
+          commonCount++;
+        }
+        if (commonCount) {
+          basePath.lastComponent = {
+            count: commonCount,
+            previousComponent: basePath.lastComponent
+          };
+        }
+        basePath.oldPos = oldPos;
+        return newPos;
+      },
+      equals: function equals2(left, right) {
+        if (this.options.comparator) {
+          return this.options.comparator(left, right);
+        } else {
+          return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+        }
+      },
+      removeEmpty: function removeEmpty2(array) {
+        var ret = [];
+        for (var i = 0; i < array.length; i++) {
+          if (array[i]) {
+            ret.push(array[i]);
+          }
+        }
+        return ret;
+      },
+      castInput: function castInput2(value) {
+        return value;
+      },
+      tokenize: function tokenize2(value) {
+        return value.split("");
+      },
+      join: function join4(chars) {
+        return chars.join("");
+      }
+    };
+    function buildValues2(diff2, lastComponent, newString, oldString, useLongestToken) {
+      var components = [];
+      var nextComponent;
+      while (lastComponent) {
+        components.push(lastComponent);
+        nextComponent = lastComponent.previousComponent;
+        delete lastComponent.previousComponent;
+        lastComponent = nextComponent;
+      }
+      components.reverse();
+      var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
+      for (; componentPos < componentLen; componentPos++) {
+        var component = components[componentPos];
+        if (!component.removed) {
+          if (!component.added && useLongestToken) {
+            var value = newString.slice(newPos, newPos + component.count);
+            value = value.map(function(value2, i) {
+              var oldValue = oldString[oldPos + i];
+              return oldValue.length > value2.length ? oldValue : value2;
+            });
+            component.value = diff2.join(value);
+          } else {
+            component.value = diff2.join(newString.slice(newPos, newPos + component.count));
+          }
+          newPos += component.count;
+          if (!component.added) {
+            oldPos += component.count;
+          }
+        } else {
+          component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
+          oldPos += component.count;
+          if (componentPos && components[componentPos - 1].added) {
+            var tmp = components[componentPos - 1];
+            components[componentPos - 1] = components[componentPos];
+            components[componentPos] = tmp;
+          }
+        }
+      }
+      var finalComponent = components[componentLen - 1];
+      if (componentLen > 1 && typeof finalComponent.value === "string" && (finalComponent.added || finalComponent.removed) && diff2.equals("", finalComponent.value)) {
+        components[componentLen - 2].value += finalComponent.value;
+        components.pop();
+      }
+      return components;
+    }
+    var characterDiff2 = new Diff2();
+    function diffChars2(oldStr, newStr, options) {
+      return characterDiff2.diff(oldStr, newStr, options);
+    }
+    var extendedWordChars2 = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+    var reWhitespace2 = /\S/;
+    var wordDiff2 = new Diff2();
+    wordDiff2.equals = function(left, right) {
+      if (this.options.ignoreCase) {
+        left = left.toLowerCase();
+        right = right.toLowerCase();
+      }
+      return left === right || this.options.ignoreWhitespace && !reWhitespace2.test(left) && !reWhitespace2.test(right);
+    };
+    wordDiff2.tokenize = function(value) {
+      var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
+      for (var i = 0; i < tokens.length - 1; i++) {
+        if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars2.test(tokens[i]) && extendedWordChars2.test(tokens[i + 2])) {
+          tokens[i] += tokens[i + 2];
+          tokens.splice(i + 1, 2);
+          i--;
+        }
+      }
+      return tokens;
+    };
+    function diffWordsWithSpace2(oldStr, newStr, options) {
+      return wordDiff2.diff(oldStr, newStr, options);
+    }
+    var lineDiff2 = new Diff2();
+    lineDiff2.tokenize = function(value) {
+      if (this.options.stripTrailingCr) {
+        value = value.replace(/\r\n/g, "\n");
+      }
+      var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+      if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+        linesAndNewlines.pop();
+      }
+      for (var i = 0; i < linesAndNewlines.length; i++) {
+        var line = linesAndNewlines[i];
+        if (i % 2 && !this.options.newlineIsToken) {
+          retLines[retLines.length - 1] += line;
+        } else {
+          if (this.options.ignoreWhitespace) {
+            line = line.trim();
+          }
+          retLines.push(line);
+        }
+      }
+      return retLines;
+    };
+    var sentenceDiff2 = new Diff2();
+    sentenceDiff2.tokenize = function(value) {
+      return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+    };
+    var cssDiff2 = new Diff2();
+    cssDiff2.tokenize = function(value) {
+      return value.split(/([{}:;,]|\s+)/);
+    };
+    function _typeof2(obj) {
+      "@babel/helpers - typeof";
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof2 = function(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof2 = function(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof2(obj);
+    }
+    var objectPrototypeToString2 = Object.prototype.toString;
+    var jsonDiff2 = new Diff2();
+    jsonDiff2.useLongestToken = true;
+    jsonDiff2.tokenize = lineDiff2.tokenize;
+    jsonDiff2.castInput = function(value) {
+      var _this$options = this.options, undefinedReplacement = _this$options.undefinedReplacement, _this$options$stringi = _this$options.stringifyReplacer, stringifyReplacer = _this$options$stringi === void 0 ? function(k, v) {
+        return typeof v === "undefined" ? undefinedReplacement : v;
+      } : _this$options$stringi;
+      return typeof value === "string" ? value : JSON.stringify(canonicalize2(value, null, null, stringifyReplacer), stringifyReplacer, "  ");
+    };
+    jsonDiff2.equals = function(left, right) {
+      return Diff2.prototype.equals.call(jsonDiff2, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"));
+    };
+    function canonicalize2(obj, stack, replacementStack, replacer, key) {
+      stack = stack || [];
+      replacementStack = replacementStack || [];
+      if (replacer) {
+        obj = replacer(key, obj);
+      }
+      var i;
+      for (i = 0; i < stack.length; i += 1) {
+        if (stack[i] === obj) {
+          return replacementStack[i];
+        }
+      }
+      var canonicalizedObj;
+      if ("[object Array]" === objectPrototypeToString2.call(obj)) {
+        stack.push(obj);
+        canonicalizedObj = new Array(obj.length);
+        replacementStack.push(canonicalizedObj);
+        for (i = 0; i < obj.length; i += 1) {
+          canonicalizedObj[i] = canonicalize2(obj[i], stack, replacementStack, replacer, key);
+        }
+        stack.pop();
+        replacementStack.pop();
+        return canonicalizedObj;
+      }
+      if (obj && obj.toJSON) {
+        obj = obj.toJSON();
+      }
+      if (_typeof2(obj) === "object" && obj !== null) {
+        stack.push(obj);
+        canonicalizedObj = {};
+        replacementStack.push(canonicalizedObj);
+        var sortedKeys = [], _key;
+        for (_key in obj) {
+          if (obj.hasOwnProperty(_key)) {
+            sortedKeys.push(_key);
+          }
+        }
+        sortedKeys.sort();
+        for (i = 0; i < sortedKeys.length; i += 1) {
+          _key = sortedKeys[i];
+          canonicalizedObj[_key] = canonicalize2(obj[_key], stack, replacementStack, replacer, _key);
+        }
+        stack.pop();
+        replacementStack.pop();
+      } else {
+        canonicalizedObj = obj;
+      }
+      return canonicalizedObj;
+    }
+    var arrayDiff2 = new Diff2();
+    arrayDiff2.tokenize = function(value) {
+      return value.slice();
+    };
+    arrayDiff2.join = arrayDiff2.removeEmpty = function(value) {
+      return value;
+    };
+    function diffArrays2(oldArr, newArr, callback) {
+      return arrayDiff2.diff(oldArr, newArr, callback);
+    }
+    var DEFAULT_MAX_INLINE_HIGHLIGHT_LINE_LENGTH2 = 500;
+    var DEFAULT_DIFF_TIMEOUT_MS2 = 100;
+    var MAX_INLINE_HIGHLIGHT_LINE_LENGTH2 = readPositiveIntegerEnv4(
+      "BYGONE_MAX_INLINE_HIGHLIGHT_LINE_LENGTH",
+      DEFAULT_MAX_INLINE_HIGHLIGHT_LINE_LENGTH2
+    );
+    var DIFF_TIMEOUT_MS2 = readPositiveIntegerEnv4("BYGONE_DIFF_TIMEOUT_MS", DEFAULT_DIFF_TIMEOUT_MS2);
+    function buildTwoWayDiffModel3(leftContent, rightContent, options = {}) {
+      const leftLines = normalizeLines2(leftContent);
+      const rightLines = normalizeLines2(rightContent);
+      const changes = diffArrays2(leftLines, rightLines, {
+        timeout: options.timeoutMs ?? DIFF_TIMEOUT_MS2
+      });
+      if (!changes) {
+        return buildConservativeTwoWayDiffModel2(leftLines, rightLines);
+      }
+      const rows = [];
+      const renderedLeftLines = [];
+      const renderedRightLines = [];
+      const blocks = [];
+      let leftLineNumber = 1;
+      let rightLineNumber = 1;
+      for (let index = 0; index < changes.length; index++) {
+        const change = changes[index];
+        const removedLines = change.removed ? change.value : [];
+        const addedLines = change.added ? change.value : [];
+        if (!change.added && !change.removed) {
+          for (const line of change.value) {
+            renderedLeftLines.push(makeDiffLine2("context", line, leftLineNumber));
+            renderedRightLines.push(makeDiffLine2("context", line, rightLineNumber));
+            rows.push(makeDiffRow2(
+              makeDiffCell2("context", line, leftLineNumber++),
+              makeDiffCell2("context", line, rightLineNumber++)
+            ));
+          }
+          continue;
+        }
+        if (change.removed && index + 1 < changes.length && changes[index + 1].added) {
+          const nextChange = changes[index + 1];
+          const leftStart = renderedLeftLines.length;
+          const rightStart = renderedRightLines.length;
+          const alignedLines = alignReplacementLines2(removedLines, nextChange.value);
+          for (const { left: removedLine, right: addedLine } of alignedLines) {
+            let renderedLeftLine;
+            let renderedRightLine;
+            if (removedLine !== void 0) {
+              renderedLeftLine = makeDiffLine2("removed", removedLine, leftLineNumber);
+              renderedLeftLines.push(renderedLeftLine);
+            }
+            if (addedLine !== void 0) {
+              renderedRightLine = makeDiffLine2("added", addedLine, rightLineNumber);
+              renderedRightLines.push(renderedRightLine);
+            }
+            if (renderedLeftLine && renderedRightLine) {
+              applyInlineHighlightPair2(renderedLeftLine, renderedRightLine);
+            }
+            rows.push(makeDiffRow2(
+              removedLine === void 0 ? makePlaceholder2() : makeDiffCell2("removed", removedLine, leftLineNumber++),
+              addedLine === void 0 ? makePlaceholder2() : makeDiffCell2("added", addedLine, rightLineNumber++)
+            ));
+          }
+          blocks.push(makeDiffBlock2("replace", leftStart, renderedLeftLines.length, rightStart, renderedRightLines.length));
+          index++;
+          continue;
+        }
+        if (change.removed) {
+          const leftStart = renderedLeftLines.length;
+          const rightStart = renderedRightLines.length;
+          for (const line of removedLines) {
+            renderedLeftLines.push(makeDiffLine2("removed", line, leftLineNumber));
+            rows.push(makeDiffRow2(
+              makeDiffCell2("removed", line, leftLineNumber++),
+              makePlaceholder2()
+            ));
+          }
+          blocks.push(makeDiffBlock2("delete", leftStart, renderedLeftLines.length, rightStart, renderedRightLines.length));
+          continue;
+        }
+        if (change.added) {
+          const leftStart = renderedLeftLines.length;
+          const rightStart = renderedRightLines.length;
+          for (const line of addedLines) {
+            renderedRightLines.push(makeDiffLine2("added", line, rightLineNumber));
+            rows.push(makeDiffRow2(
+              makePlaceholder2(),
+              makeDiffCell2("added", line, rightLineNumber++)
+            ));
+          }
+          blocks.push(makeDiffBlock2("insert", leftStart, renderedLeftLines.length, rightStart, renderedRightLines.length));
+        }
+      }
+      const hasChanges = rows.some((row) => row.left.kind !== "context" || row.right.kind !== "context");
+      return {
+        rows,
+        leftLines: renderedLeftLines,
+        rightLines: renderedRightLines,
+        blocks,
+        hasChanges
+      };
+    }
+    function buildConservativeTwoWayDiffModel2(leftLines, rightLines) {
+      const renderedLeftLines = leftLines.map((line, index) => makeDiffLine2("removed", line, index + 1));
+      const renderedRightLines = rightLines.map((line, index) => makeDiffLine2("added", line, index + 1));
+      const rows = [
+        ...leftLines.map((line, index) => makeDiffRow2(
+          makeDiffCell2("removed", line, index + 1),
+          makePlaceholder2()
+        )),
+        ...rightLines.map((line, index) => makeDiffRow2(
+          makePlaceholder2(),
+          makeDiffCell2("added", line, index + 1)
+        ))
+      ];
+      let blockKind = "replace";
+      if (leftLines.length === 0) {
+        blockKind = "insert";
+      } else if (rightLines.length === 0) {
+        blockKind = "delete";
+      }
+      return {
+        rows,
+        leftLines: renderedLeftLines,
+        rightLines: renderedRightLines,
+        blocks: rows.length === 0 ? [] : [makeDiffBlock2(blockKind, 0, leftLines.length, 0, rightLines.length)],
+        hasChanges: rows.length > 0
+      };
+    }
+    function normalizeLines2(content) {
+      if (content.length === 0) {
+        return [];
+      }
+      const lines = content.replace(/\r\n/g, "\n").split("\n");
+      if (lines[lines.length - 1] === "") {
+        lines.pop();
+      }
+      return lines;
+    }
+    var MAX_ALIGNMENT_CELLS2 = 1e4;
+    var MAX_SCORING_LINE_LENGTH2 = 2e3;
+    var MINIMUM_MATCH_SCORE2 = 0.52;
+    var MINIMUM_SINGLE_PAIR_SCORE2 = 0.35;
+    var MINIMUM_CONTEXTUAL_MATCH_SCORE2 = 0.38;
+    var MINIMUM_CONTEXTUAL_RUN_SCORE2 = 0.33;
+    var HIGH_CONFIDENCE_MATCH_SCORE2 = 0.86;
+    var AMBIGUITY_MARGIN2 = 0.08;
+    var CONTEXTUAL_AMBIGUITY_MARGIN2 = 0.05;
+    var GAP_PENALTY2 = -0.12;
+    var MAX_BOUNDED_CANDIDATES2 = 5e3;
+    var MAX_LARGE_HUNK_ANCHORS2 = 2e3;
+    var MAX_RARE_TOKEN_OCCURRENCES2 = 4;
+    var MAX_CONTEXTUAL_HUNK_LINES2 = 8;
+    var MAX_CONTEXTUAL_LENGTH_DELTA2 = 4;
+    function alignReplacementLines2(leftLines, rightLines) {
+      if (leftLines.length === 0) {
+        return rightLines.map((right) => ({ right }));
+      }
+      if (rightLines.length === 0) {
+        return leftLines.map((left) => ({ left }));
+      }
+      if (leftLines.length === 1 && rightLines.length === 1) {
+        const singletonScore = scoreReplacementLinePair2(leftLines[0], rightLines[0]);
+        if ((singletonScore.eligible || singletonScore.score >= MINIMUM_SINGLE_PAIR_SCORE2) && haveCompatibleLineRoles2(leftLines[0], rightLines[0]) && isInformativeLine2(normalizeMatchingContent2(leftLines[0])) && isInformativeLine2(normalizeMatchingContent2(rightLines[0]))) {
+          return [{ left: leftLines[0], right: rightLines[0] }];
+        }
+        return [{ left: leftLines[0] }, { right: rightLines[0] }];
+      }
+      if (leftLines.length * rightLines.length > MAX_ALIGNMENT_CELLS2) {
+        return alignLargeReplacementLines2(leftLines, rightLines);
+      }
+      const pairScores = buildPairScores2(leftLines, rightLines);
+      const scores = Array.from(
+        { length: leftLines.length + 1 },
+        () => new Array(rightLines.length + 1).fill(Number.NEGATIVE_INFINITY)
+      );
+      const moves = Array.from(
+        { length: leftLines.length + 1 },
+        () => new Array(rightLines.length + 1).fill(null)
+      );
+      scores[0][0] = 0;
+      for (let leftIndex2 = 1; leftIndex2 <= leftLines.length; leftIndex2++) {
+        scores[leftIndex2][0] = scores[leftIndex2 - 1][0] + GAP_PENALTY2;
+        moves[leftIndex2][0] = "left";
+      }
+      for (let rightIndex2 = 1; rightIndex2 <= rightLines.length; rightIndex2++) {
+        scores[0][rightIndex2] = scores[0][rightIndex2 - 1] + GAP_PENALTY2;
+        moves[0][rightIndex2] = "right";
+      }
+      for (let leftIndex2 = 1; leftIndex2 <= leftLines.length; leftIndex2++) {
+        for (let rightIndex2 = 1; rightIndex2 <= rightLines.length; rightIndex2++) {
+          const pairScore = pairScores[leftIndex2 - 1][rightIndex2 - 1];
+          const candidates = [
+            { move: "left", score: scores[leftIndex2 - 1][rightIndex2] + GAP_PENALTY2 },
+            { move: "right", score: scores[leftIndex2][rightIndex2 - 1] + GAP_PENALTY2 },
+            {
+              move: "match",
+              score: pairScore === null ? Number.NEGATIVE_INFINITY : scores[leftIndex2 - 1][rightIndex2 - 1] + pairScore
+            }
+          ];
+          const best = candidates.reduce((current, candidate) => candidate.score > current.score ? candidate : current);
+          scores[leftIndex2][rightIndex2] = best.score;
+          moves[leftIndex2][rightIndex2] = best.move;
+        }
+      }
+      const aligned = [];
+      let leftIndex = leftLines.length;
+      let rightIndex = rightLines.length;
+      while (leftIndex > 0 || rightIndex > 0) {
+        const move = moves[leftIndex][rightIndex];
+        if (move === "match") {
+          aligned.push({ left: leftLines[--leftIndex], right: rightLines[--rightIndex] });
+        } else if (move === "left") {
+          aligned.push({ left: leftLines[--leftIndex] });
+        } else {
+          aligned.push({ right: rightLines[--rightIndex] });
+        }
+      }
+      return aligned.reverse();
+    }
+    function scoreReplacementLinePair2(left, right) {
+      const normalizedLeft = normalizeMatchingContent2(left);
+      const normalizedRight = normalizeMatchingContent2(right);
+      const leftInformative = isInformativeLine2(normalizedLeft);
+      const rightInformative = isInformativeLine2(normalizedRight);
+      if (!leftInformative || !rightInformative || normalizedLeft.length > MAX_SCORING_LINE_LENGTH2 || normalizedRight.length > MAX_SCORING_LINE_LENGTH2) {
+        return {
+          score: 0,
+          eligible: false,
+          characterSimilarity: 0,
+          tokenSimilarity: 0,
+          lengthSimilarity: 0
+        };
+      }
+      if (normalizedLeft === normalizedRight) {
+        return {
+          score: 1,
+          eligible: true,
+          characterSimilarity: 1,
+          tokenSimilarity: 1,
+          lengthSimilarity: 1
+        };
+      }
+      const leftTokens = tokenizeMatchingContent2(normalizedLeft);
+      const rightTokens = tokenizeMatchingContent2(normalizedRight);
+      const characterSimilarity = lineSimilarity2(normalizedLeft, normalizedRight);
+      const tokenSimilarity = multisetDiceSimilarity2(leftTokens, rightTokens);
+      const lengthSimilarity = Math.min(normalizedLeft.length, normalizedRight.length) / Math.max(normalizedLeft.length, normalizedRight.length);
+      const boundarySimilarity = tokenBoundarySimilarity2(leftTokens, rightTokens);
+      const score = characterSimilarity * 0.52 + tokenSimilarity * 0.32 + lengthSimilarity * 0.1 + boundarySimilarity * 0.06;
+      const hasContentEvidence = characterSimilarity >= 0.52 || tokenSimilarity >= 0.45 || characterSimilarity >= 0.48 && tokenSimilarity >= 0.28;
+      return {
+        score,
+        eligible: hasContentEvidence && score >= MINIMUM_MATCH_SCORE2,
+        characterSimilarity,
+        tokenSimilarity,
+        lengthSimilarity
+      };
+    }
+    function buildPairScores2(leftLines, rightLines) {
+      const scored = leftLines.map((left) => rightLines.map((right) => scoreReplacementLinePair2(left, right)));
+      const structuralPairs = collectUniqueStructuralPairs2(leftLines, rightLines);
+      const leftRankings = scored.map((row) => rankEligibleScores2(row));
+      const rightRankings = rightLines.map((_right, rightIndex) => rankEligibleScores2(scored.map((row) => row[rightIndex])));
+      const accepted = scored.map((row, leftIndex) => row.map((candidate, rightIndex) => {
+        if (structuralPairs.has(`${leftIndex}:${rightIndex}`)) {
+          return Math.max(candidate.score, 1);
+        }
+        if (!candidate.eligible) {
+          return null;
+        }
+        const leftRanking = leftRankings[leftIndex];
+        const rightRanking = rightRankings[rightIndex];
+        const isBestOnBothSides = candidate.score === leftRanking.best && candidate.score === rightRanking.best;
+        const requiredMargin = candidate.score >= HIGH_CONFIDENCE_MATCH_SCORE2 ? AMBIGUITY_MARGIN2 / 2 : AMBIGUITY_MARGIN2;
+        const hasLeftMargin = leftRanking.best - leftRanking.second >= requiredMargin;
+        const hasRightMargin = rightRanking.best - rightRanking.second >= requiredMargin;
+        return isBestOnBothSides && hasLeftMargin && hasRightMargin ? candidate.score : null;
+      }));
+      if (Math.max(leftLines.length, rightLines.length) > MAX_CONTEXTUAL_HUNK_LINES2 || Math.abs(leftLines.length - rightLines.length) > MAX_CONTEXTUAL_LENGTH_DELTA2) {
+        return accepted;
+      }
+      const isContextualCandidate = (candidate, leftIndex, rightIndex) => candidate.score >= MINIMUM_CONTEXTUAL_MATCH_SCORE2 && haveCompatibleLineRoles2(leftLines[leftIndex], rightLines[rightIndex]) && Math.abs(leftIndex - rightIndex) <= MAX_CONTEXTUAL_LENGTH_DELTA2;
+      const leftContextRankings = scored.map((row, leftIndex) => rankScores2(row, (candidate, rightIndex) => isContextualCandidate(candidate, leftIndex, rightIndex)));
+      const rightContextRankings = rightLines.map((_right, rightIndex) => rankScores2(
+        scored.map((row) => row[rightIndex]),
+        (candidate, leftIndex) => isContextualCandidate(candidate, leftIndex, rightIndex)
+      ));
+      const isWeakRunCandidate = (candidate, leftIndex, rightIndex) => candidate.score >= MINIMUM_CONTEXTUAL_RUN_SCORE2 && haveCompatibleLineRoles2(leftLines[leftIndex], rightLines[rightIndex]) && Math.abs(leftIndex - rightIndex) <= MAX_CONTEXTUAL_LENGTH_DELTA2;
+      const leftWeakRankings = scored.map((row, leftIndex) => rankScores2(row, (candidate, rightIndex) => isWeakRunCandidate(candidate, leftIndex, rightIndex)));
+      const rightWeakRankings = rightLines.map((_right, rightIndex) => rankScores2(
+        scored.map((row) => row[rightIndex]),
+        (candidate, leftIndex) => isWeakRunCandidate(candidate, leftIndex, rightIndex)
+      ));
+      const isUnambiguousContextualCandidate = (leftIndex, rightIndex) => {
+        const candidate = scored[leftIndex][rightIndex];
+        if (!isContextualCandidate(candidate, leftIndex, rightIndex)) {
+          return false;
+        }
+        const leftRanking = leftContextRankings[leftIndex];
+        const rightRanking = rightContextRankings[rightIndex];
+        return candidate.score === leftRanking.best && candidate.score === rightRanking.best && leftRanking.best - leftRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2 && rightRanking.best - rightRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2;
+      };
+      const isUnambiguousWeakRunAnchor = (leftIndex, rightIndex) => {
+        const candidate = scored[leftIndex][rightIndex];
+        if (!isWeakRunCandidate(candidate, leftIndex, rightIndex)) {
+          return false;
+        }
+        const leftRanking = leftWeakRankings[leftIndex];
+        const rightRanking = rightWeakRankings[rightIndex];
+        return candidate.score === leftRanking.best && candidate.score === rightRanking.best && leftRanking.best - leftRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2 && rightRanking.best - rightRanking.second >= CONTEXTUAL_AMBIGUITY_MARGIN2;
+      };
+      return accepted.map((row, leftIndex) => row.map((acceptedScore, rightIndex) => {
+        if (acceptedScore !== null) {
+          return acceptedScore;
+        }
+        const hasLocalSupport = isUnambiguousContextualCandidate(leftIndex, rightIndex) && (hasAcceptedDiagonalNeighbor2(accepted, leftIndex, rightIndex) || hasContextualDiagonalNeighbor2(
+          scored,
+          leftIndex,
+          rightIndex,
+          isUnambiguousContextualCandidate
+        ));
+        const hasRunSupport = hasAnchoredWeakDiagonalRun2(
+          scored,
+          leftIndex,
+          rightIndex,
+          (candidateLeftIndex, candidateRightIndex) => isWeakRunCandidate(
+            scored[candidateLeftIndex][candidateRightIndex],
+            candidateLeftIndex,
+            candidateRightIndex
+          ),
+          isUnambiguousWeakRunAnchor
+        );
+        if (!hasLocalSupport && !hasRunSupport) {
+          return null;
+        }
+        return scored[leftIndex][rightIndex].score;
+      }));
+    }
+    function hasAcceptedDiagonalNeighbor2(accepted, leftIndex, rightIndex) {
+      return leftIndex > 0 && rightIndex > 0 && accepted[leftIndex - 1][rightIndex - 1] !== null || leftIndex + 1 < accepted.length && rightIndex + 1 < accepted[leftIndex + 1].length && accepted[leftIndex + 1][rightIndex + 1] !== null;
+    }
+    function hasContextualDiagonalNeighbor2(scored, leftIndex, rightIndex, isCandidate) {
+      return leftIndex > 0 && rightIndex > 0 && isCandidate(leftIndex - 1, rightIndex - 1) || leftIndex + 1 < scored.length && rightIndex + 1 < scored[leftIndex + 1].length && isCandidate(leftIndex + 1, rightIndex + 1);
+    }
+    function hasAnchoredWeakDiagonalRun2(scored, leftIndex, rightIndex, isCandidate, isAnchor) {
+      let startLeft = leftIndex;
+      let startRight = rightIndex;
+      while (startLeft > 0 && startRight > 0 && isCandidate(startLeft - 1, startRight - 1)) {
+        startLeft--;
+        startRight--;
+      }
+      let endLeft = leftIndex;
+      let endRight = rightIndex;
+      let scoreTotal = scored[leftIndex][rightIndex].score;
+      let length = 1;
+      while (endLeft + 1 < scored.length && endRight + 1 < scored[endLeft + 1].length && isCandidate(endLeft + 1, endRight + 1)) {
+        endLeft++;
+        endRight++;
+        scoreTotal += scored[endLeft][endRight].score;
+        length++;
+      }
+      for (let scanLeft = leftIndex - 1, scanRight = rightIndex - 1; scanLeft >= startLeft && scanRight >= startRight; scanLeft--, scanRight--) {
+        scoreTotal += scored[scanLeft][scanRight].score;
+        length++;
+      }
+      return length >= 3 && scoreTotal / length >= MINIMUM_CONTEXTUAL_MATCH_SCORE2 && isAnchor(startLeft, startRight) && isAnchor(endLeft, endRight);
+    }
+    function rankScores2(scores, include) {
+      let best = Number.NEGATIVE_INFINITY;
+      let second = Number.NEGATIVE_INFINITY;
+      scores.forEach((candidate, index) => {
+        if (!include(candidate, index)) {
+          return;
+        }
+        if (candidate.score > best) {
+          second = best;
+          best = candidate.score;
+        } else if (candidate.score > second) {
+          second = candidate.score;
+        }
+      });
+      return { best, second };
+    }
+    function rankEligibleScores2(scores) {
+      let best = Number.NEGATIVE_INFINITY;
+      let second = Number.NEGATIVE_INFINITY;
+      for (const candidate of scores) {
+        if (!candidate.eligible) {
+          continue;
+        }
+        if (candidate.score > best) {
+          second = best;
+          best = candidate.score;
+        } else if (candidate.score > second) {
+          second = candidate.score;
+        }
+      }
+      return { best, second };
+    }
+    function alignLargeReplacementLines2(leftLines, rightLines) {
+      const anchors = collectLargeHunkAnchors2(leftLines, rightLines);
+      const aligned = [];
+      let leftStart = 0;
+      let rightStart = 0;
+      for (const anchor of anchors) {
+        appendBoundedSegment2(
+          aligned,
+          leftLines.slice(leftStart, anchor.leftIndex),
+          rightLines.slice(rightStart, anchor.rightIndex)
+        );
+        aligned.push({ left: leftLines[anchor.leftIndex], right: rightLines[anchor.rightIndex] });
+        leftStart = anchor.leftIndex + 1;
+        rightStart = anchor.rightIndex + 1;
+      }
+      appendBoundedSegment2(aligned, leftLines.slice(leftStart), rightLines.slice(rightStart));
+      return aligned;
+    }
+    function collectLargeHunkAnchors2(leftLines, rightLines) {
+      const candidatePairs = collectRareTokenCandidatePairs2(leftLines, rightLines);
+      if (candidatePairs === null) {
+        return [];
+      }
+      const structuralPairs = collectUniqueStructuralPairs2(leftLines, rightLines);
+      const scored = candidatePairs.map(({ leftIndex, rightIndex, exact }) => ({
+        leftIndex,
+        rightIndex,
+        exact,
+        structural: structuralPairs.has(`${leftIndex}:${rightIndex}`),
+        match: scoreReplacementLinePair2(leftLines[leftIndex], rightLines[rightIndex])
+      })).filter((candidate) => candidate.exact || candidate.structural || candidate.match.eligible);
+      const leftRankings = rankAnchorCandidates2(scored, "leftIndex");
+      const rightRankings = rankAnchorCandidates2(scored, "rightIndex");
+      const confident = scored.filter((candidate) => {
+        if (candidate.exact || candidate.structural) {
+          return true;
+        }
+        const leftRanking = leftRankings.get(candidate.leftIndex);
+        const rightRanking = rightRankings.get(candidate.rightIndex);
+        if (!leftRanking || !rightRanking || candidate.match.score !== leftRanking.best || candidate.match.score !== rightRanking.best) {
+          return false;
+        }
+        const requiredMargin = candidate.match.score >= HIGH_CONFIDENCE_MATCH_SCORE2 ? AMBIGUITY_MARGIN2 / 2 : AMBIGUITY_MARGIN2;
+        return leftRanking.best - leftRanking.second >= requiredMargin && rightRanking.best - rightRanking.second >= requiredMargin;
+      });
+      const anchors = selectMaximumWeightMonotonicAnchors2(confident, rightLines.length);
+      return anchors.length <= MAX_LARGE_HUNK_ANCHORS2 ? anchors : [];
+    }
+    function collectRareTokenCandidatePairs2(leftLines, rightLines) {
+      const leftExact = buildLinePostings2(leftLines, normalizeMatchingContent2);
+      const rightExact = buildLinePostings2(rightLines, normalizeMatchingContent2);
+      const pairs = /* @__PURE__ */ new Map();
+      for (const [line, leftIndices] of leftExact) {
+        const rightIndices = rightExact.get(line);
+        if (!isInformativeLine2(line) || leftIndices.length !== 1 || (rightIndices == null ? void 0 : rightIndices.length) !== 1) {
+          continue;
+        }
+        const leftIndex = leftIndices[0];
+        const rightIndex = rightIndices[0];
+        pairs.set(`${leftIndex}:${rightIndex}`, { leftIndex, rightIndex, exact: true });
+        if (pairs.size > MAX_BOUNDED_CANDIDATES2) {
+          return null;
+        }
+      }
+      const leftTokens = buildTokenPostings2(leftLines);
+      const rightTokens = buildTokenPostings2(rightLines);
+      for (const [token, leftIndices] of leftTokens) {
+        const rightIndices = rightTokens.get(token);
+        if (!rightIndices || leftIndices.length > MAX_RARE_TOKEN_OCCURRENCES2 || rightIndices.length > MAX_RARE_TOKEN_OCCURRENCES2) {
+          continue;
+        }
+        for (const leftIndex of leftIndices) {
+          for (const rightIndex of rightIndices) {
+            const key = `${leftIndex}:${rightIndex}`;
+            if (!pairs.has(key)) {
+              pairs.set(key, { leftIndex, rightIndex, exact: false });
+              if (pairs.size > MAX_BOUNDED_CANDIDATES2) {
+                return null;
+              }
+            }
+          }
+        }
+      }
+      return [...pairs.values()];
+    }
+    function buildLinePostings2(lines, keyForLine) {
+      const postings = /* @__PURE__ */ new Map();
+      lines.forEach((line, index) => {
+        const key = keyForLine(line);
+        const indices = postings.get(key) ?? [];
+        indices.push(index);
+        postings.set(key, indices);
+      });
+      return postings;
+    }
+    function buildTokenPostings2(lines) {
+      const postings = /* @__PURE__ */ new Map();
+      lines.forEach((line, index) => {
+        const tokens = new Set(tokenizeMatchingContent2(normalizeMatchingContent2(line)).filter(isMeaningfulAnchorToken2));
+        for (const token of tokens) {
+          const indices = postings.get(token) ?? [];
+          indices.push(index);
+          postings.set(token, indices);
+        }
+      });
+      return postings;
+    }
+    function isMeaningfulAnchorToken2(token) {
+      return token.length >= 2 && /[\p{L}\p{N}_$]/u.test(token);
+    }
+    function rankAnchorCandidates2(candidates, indexKey) {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const candidate of candidates) {
+        const scores = grouped.get(candidate[indexKey]) ?? [];
+        scores.push(candidate.match);
+        grouped.set(candidate[indexKey], scores);
+      }
+      return new Map([...grouped].map(([index, scores]) => [index, rankEligibleScores2(scores)]));
+    }
+    function selectMaximumWeightMonotonicAnchors2(candidates, rightLength) {
+      const ordered = [...candidates].sort((left, right) => left.leftIndex - right.leftIndex || left.rightIndex - right.rightIndex);
+      const treeScores = new Array(rightLength + 2).fill(0);
+      const treeCandidates = new Array(rightLength + 2).fill(-1);
+      const bestScores = new Array(ordered.length).fill(0);
+      const previous = new Array(ordered.length).fill(-1);
+      for (let start = 0; start < ordered.length; ) {
+        let end = start + 1;
+        while (end < ordered.length && ordered[end].leftIndex === ordered[start].leftIndex) {
+          end++;
+        }
+        for (let index = start; index < end; index++) {
+          const prior = queryAnchorTree2(treeScores, treeCandidates, ordered[index].rightIndex);
+          const anchorBonus = ordered[index].exact || ordered[index].structural ? 0.5 : 0;
+          bestScores[index] = prior.score + ordered[index].match.score + anchorBonus;
+          previous[index] = prior.candidateIndex;
+        }
+        for (let index = start; index < end; index++) {
+          updateAnchorTree2(
+            treeScores,
+            treeCandidates,
+            ordered[index].rightIndex + 1,
+            bestScores[index],
+            index
+          );
+        }
+        start = end;
+      }
+      const best = queryAnchorTree2(treeScores, treeCandidates, rightLength + 1);
+      const anchors = [];
+      for (let index = best.candidateIndex; index >= 0; index = previous[index]) {
+        anchors.push({ leftIndex: ordered[index].leftIndex, rightIndex: ordered[index].rightIndex });
+      }
+      return anchors.reverse();
+    }
+    function queryAnchorTree2(scores, candidates, position) {
+      let score = 0;
+      let candidateIndex = -1;
+      for (let index = position; index > 0; index -= index & -index) {
+        if (scores[index] > score) {
+          score = scores[index];
+          candidateIndex = candidates[index];
+        }
+      }
+      return { score, candidateIndex };
+    }
+    function updateAnchorTree2(scores, candidates, position, score, candidateIndex) {
+      for (let index = position; index < scores.length; index += index & -index) {
+        if (score > scores[index]) {
+          scores[index] = score;
+          candidates[index] = candidateIndex;
+        }
+      }
+    }
+    function appendBoundedSegment2(aligned, leftLines, rightLines) {
+      if (leftLines.length * rightLines.length <= MAX_ALIGNMENT_CELLS2) {
+        aligned.push(...alignReplacementLines2(leftLines, rightLines));
+        return;
+      }
+      aligned.push(...leftLines.map((left) => ({ left })));
+      aligned.push(...rightLines.map((right) => ({ right })));
+    }
+    function normalizeMatchingContent2(line) {
+      return line.trim().replace(/\s+/g, " ");
+    }
+    function collectUniqueStructuralPairs2(leftLines, rightLines) {
+      const leftPostings = buildStructuralPostings2(leftLines);
+      const rightPostings = buildStructuralPostings2(rightLines);
+      const pairs = /* @__PURE__ */ new Set();
+      for (const [key, leftIndices] of leftPostings) {
+        const rightIndices = rightPostings.get(key);
+        if (leftIndices.length === 1 && (rightIndices == null ? void 0 : rightIndices.length) === 1) {
+          pairs.add(`${leftIndices[0]}:${rightIndices[0]}`);
+        }
+      }
+      return pairs;
+    }
+    function buildStructuralPostings2(lines) {
+      const postings = /* @__PURE__ */ new Map();
+      lines.forEach((line, index) => {
+        const key = declarationAnchorKey2(line);
+        if (!key) {
+          return;
+        }
+        const indices = postings.get(key) ?? [];
+        indices.push(index);
+        postings.set(key, indices);
+      });
+      return postings;
+    }
+    function haveCompatibleLineRoles2(left, right) {
+      const leftKey = declarationAnchorKey2(left);
+      const rightKey = declarationAnchorKey2(right);
+      if (!leftKey || !rightKey) {
+        return leftKey === rightKey;
+      }
+      return leftKey.split(":", 1)[0] === rightKey.split(":", 1)[0];
+    }
+    function declarationAnchorKey2(line) {
+      const normalized = normalizeMatchingContent2(line);
+      const patterns = [
+        ["function", /^(?:(?:export|default)\s+)*(?:async\s+)?function\s*\*?\s*([\p{L}_$][\p{L}\p{N}_$]*)\s*\(/u],
+        ["function", /^(?:async\s+)?def\s+([\p{L}_][\p{L}\p{N}_]*)\s*\(/u],
+        ["function", /^(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?fn\s+([\p{L}_][\p{L}\p{N}_]*)\s*(?:<[^>]*>)?\s*\(/u],
+        ["function", /^func\s+(?:\([^)]*\)\s*)?([\p{L}_][\p{L}\p{N}_]*)\s*\(/u],
+        ["class", /^(?:(?:export|default|abstract|public)\s+)*class\s+([\p{L}_$][\p{L}\p{N}_$]*)\b/u]
+      ];
+      for (const [kind, pattern] of patterns) {
+        const match = normalized.match(pattern);
+        if (match) {
+          return `${kind}:${match[1]}`;
+        }
+      }
+      return null;
+    }
+    function isInformativeLine2(line) {
+      if (line.length < 3) {
+        return false;
+      }
+      return /[\p{L}\p{N}_$]/u.test(line) && !/^[\s()[\]{};,.:+\-*/=>|&!?'"`]+$/.test(line);
+    }
+    function tokenizeMatchingContent2(line) {
+      return line.toLowerCase().match(new RegExp("[\\p{L}_$][\\p{L}\\p{N}_$]*|\\p{N}+(?:\\.\\p{N}+)?|[^\\s\\p{L}\\p{N}_$]", "gu")) ?? [];
+    }
+    function multisetDiceSimilarity2(leftTokens, rightTokens) {
+      if (leftTokens.length + rightTokens.length === 0) {
+        return 1;
+      }
+      const remaining = /* @__PURE__ */ new Map();
+      leftTokens.forEach((token) => remaining.set(token, (remaining.get(token) ?? 0) + 1));
+      let common = 0;
+      for (const token of rightTokens) {
+        const count = remaining.get(token) ?? 0;
+        if (count > 0) {
+          common++;
+          remaining.set(token, count - 1);
+        }
+      }
+      return 2 * common / (leftTokens.length + rightTokens.length);
+    }
+    function tokenBoundarySimilarity2(leftTokens, rightTokens) {
+      if (leftTokens.length === 0 || rightTokens.length === 0) {
+        return 0;
+      }
+      const sameStart = leftTokens[0] === rightTokens[0] ? 0.5 : 0;
+      const sameEnd = leftTokens[leftTokens.length - 1] === rightTokens[rightTokens.length - 1] ? 0.5 : 0;
+      return sameStart + sameEnd;
+    }
+    function lineSimilarity2(left, right) {
+      const maxLength = left.length + right.length;
+      if (maxLength === 0) {
+        return 1;
+      }
+      const commonLength = diffChars2(left, right).filter((change) => !change.added && !change.removed).reduce((total, change) => total + change.value.length, 0);
+      return 2 * commonLength / maxLength;
+    }
+    function applyInlineHighlightPair2(leftLine, rightLine) {
+      if (leftLine.content.length > MAX_INLINE_HIGHLIGHT_LINE_LENGTH2 || rightLine.content.length > MAX_INLINE_HIGHLIGHT_LINE_LENGTH2) {
+        return;
+      }
+      const { leftSegments, rightSegments, hasInlineChanges } = buildInlineSegments2(leftLine.content, rightLine.content);
+      if (hasInlineChanges) {
+        leftLine.segments = leftSegments;
+        rightLine.segments = rightSegments;
+      }
+    }
+    function buildInlineSegments2(leftContent, rightContent) {
+      const changes = diffWordsWithSpace2(leftContent, rightContent);
+      const leftSegments = [];
+      const rightSegments = [];
+      let hasInlineChanges = false;
+      for (const change of changes) {
+        const value = change.value;
+        if (!change.added && !change.removed) {
+          const contextSegment = {
+            kind: "context",
+            text: value,
+            emphasis: false
+          };
+          leftSegments.push(contextSegment);
+          rightSegments.push(contextSegment);
+          continue;
+        }
+        const emphasis = /[^\s]/.test(value);
+        hasInlineChanges = hasInlineChanges || emphasis;
+        if (change.removed) {
+          leftSegments.push({
+            kind: "removed",
+            text: value,
+            emphasis
+          });
+        }
+        if (change.added) {
+          rightSegments.push({
+            kind: "added",
+            text: value,
+            emphasis
+          });
+        }
+      }
+      return {
+        leftSegments,
+        rightSegments,
+        hasInlineChanges
+      };
+    }
+    function makePlaceholder2() {
+      return {
+        kind: "placeholder",
+        content: "",
+        lineNumber: null
+      };
+    }
+    function makeDiffCell2(kind, content, lineNumber) {
+      return { kind, content, lineNumber };
+    }
+    function makeDiffLine2(kind, content, lineNumber) {
+      return { kind, content, lineNumber };
+    }
+    function makeDiffRow2(left, right) {
+      return { left, right };
+    }
+    function makeDiffBlock2(kind, leftStart, leftEnd, rightStart, rightEnd) {
+      return { kind, leftStart, leftEnd, rightStart, rightEnd };
+    }
+    function readPositiveIntegerEnv4(name, fallback) {
+      var _a;
+      const value = typeof process !== "undefined" ? (_a = process.env) == null ? void 0 : _a[name] : void 0;
+      const parsed = Number.parseInt(value ?? "", 10);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    }
+    var MAX_AUTOMATIC_TOUR_FOCUS_RANGES = 4;
+    var NEARBY_TOUR_FOCUS_LINE_GAP = 8;
+    var LARGE_TOUR_FOCUS_RANGE_LINES = 120;
+    var TOUR_FOCUS_BOUNDARY_SEARCH_LINES = 12;
+    function getChangeSourceRange(diffModel, blockIndex, side) {
+      var _a, _b, _c;
+      const block = diffModel == null ? void 0 : diffModel.blocks[blockIndex];
+      const lines = side === "left" ? diffModel == null ? void 0 : diffModel.leftLines : diffModel == null ? void 0 : diffModel.rightLines;
+      if (!block || !(lines == null ? void 0 : lines.length)) {
+        return void 0;
+      }
+      const start = side === "left" ? block.leftStart : block.rightStart;
+      const end = side === "left" ? block.leftEnd : block.rightEnd;
+      const changedLines = lines.slice(start, end);
+      const startLine = ((_a = changedLines[0]) == null ? void 0 : _a.lineNumber) ?? ((_b = lines[Math.min(start, lines.length - 1)]) == null ? void 0 : _b.lineNumber);
+      if (!Number.isInteger(startLine)) {
+        return void 0;
+      }
+      return {
+        startLine,
+        endLine: ((_c = changedLines.at(-1)) == null ? void 0 : _c.lineNumber) ?? startLine
+      };
+    }
+    function buildTourFocusRanges(diffModel, side) {
+      const ranges = diffModel.blocks.map((_, blockIndex) => getChangeSourceRange(diffModel, blockIndex, side)).filter((range) => Boolean(range));
+      if (ranges.length === 0) return [];
+      const nearby = ranges.reduce((grouped, range) => {
+        const previous = grouped.at(-1);
+        if (previous && range.startLine - previous.endLine <= NEARBY_TOUR_FOCUS_LINE_GAP) {
+          previous.endLine = Math.max(previous.endLine, range.endLine);
+        } else {
+          grouped.push({ ...range });
+        }
+        return grouped;
+      }, []);
+      const capped = capFocusRanges(nearby, MAX_AUTOMATIC_TOUR_FOCUS_RANGES);
+      if (capped.length !== 1) return capped;
+      const [only] = capped;
+      const lineCount = only.endLine - only.startLine + 1;
+      if (lineCount < LARGE_TOUR_FOCUS_RANGE_LINES) return capped;
+      const lines = side === "left" ? diffModel.leftLines : diffModel.rightLines;
+      const partCount = Math.min(
+        MAX_AUTOMATIC_TOUR_FOCUS_RANGES,
+        Math.ceil(lineCount / LARGE_TOUR_FOCUS_RANGE_LINES)
+      );
+      const boundaries = [];
+      for (let partIndex = 1; partIndex < partCount; partIndex += 1) {
+        const target = only.startLine + Math.round(lineCount * partIndex / partCount) - 1;
+        boundaries.push(findBlankLineBoundary(lines, target, only.startLine, only.endLine));
+      }
+      const uniqueBoundaries = [...new Set(boundaries)].filter((line) => line >= only.startLine && line < only.endLine).sort((left, right) => left - right);
+      const split = [];
+      let startLine = only.startLine;
+      for (const endLine of uniqueBoundaries) {
+        split.push({ startLine, endLine });
+        startLine = endLine + 1;
+      }
+      split.push({ startLine, endLine: only.endLine });
+      return split;
+    }
+    function capFocusRanges(ranges, maximum) {
+      if (ranges.length <= maximum) return ranges.map((range) => ({ ...range }));
+      const capped = [];
+      for (let index = 0; index < maximum; index += 1) {
+        const startIndex = Math.floor(index * ranges.length / maximum);
+        const endIndex = Math.floor((index + 1) * ranges.length / maximum) - 1;
+        capped.push({
+          startLine: ranges[startIndex].startLine,
+          endLine: ranges[endIndex].endLine
+        });
+      }
+      return capped;
+    }
+    function findBlankLineBoundary(lines, target, minimum, maximum) {
+      for (let distance = 0; distance <= TOUR_FOCUS_BOUNDARY_SEARCH_LINES; distance += 1) {
+        for (const candidate of distance === 0 ? [target] : [target + distance, target - distance]) {
+          if (candidate < minimum || candidate >= maximum) continue;
+          const line = lines.find((entry) => entry.lineNumber === candidate);
+          if ((line == null ? void 0 : line.content.trim()) === "") return candidate;
+        }
+      }
+      return Math.min(Math.max(target, minimum), maximum - 1);
+    }
     var import_child_process32 = require("child_process");
     var CHANGE_TOUR_CONTEXT_VERSION = 1;
     var DEFAULT_MAX_PATCH_BYTES = 128 * 1024;
@@ -5162,7 +6383,8 @@ var require_changeTour = __commonJS({
               repoRoot,
               authoredScene,
               authoredScene.base || ((_a = source.range) == null ? void 0 : _a.base),
-              authoredScene.target || ((_b = source.range) == null ? void 0 : _b.head)
+              authoredScene.target || ((_b = source.range) == null ? void 0 : _b.head),
+              [...available.keys()]
             );
             scenes.push(deconstructedScene);
             sceneIds.push(deconstructedScene.id);
@@ -5208,7 +6430,7 @@ var require_changeTour = __commonJS({
       }
       return { scenes, chapters };
     }
-    function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef) {
+    function buildDeconstructedManifestScene(repoRoot, source, baseRef, targetRef, availableFilePaths = []) {
       const compiled = buildDeconstructedScene(repoRoot, source, { baseRef, headRef: targetRef });
       const panels = [{
         id: "explanation-baseline",
@@ -5220,9 +6442,15 @@ var require_changeTour = __commonJS({
         role: "stage",
         stageId: stage.id
       }))];
-      const includedPaths = [...new Set(compiled.stages.flatMap((stage) => stage.introducedFiles))];
+      const materializablePaths = new Set(compiled.baselineFiles.map((file) => file.path));
+      const includedPaths = availableFilePaths.length > 0 ? availableFilePaths.filter((filePath) => materializablePaths.has(filePath)).sort() : [...materializablePaths].sort();
+      const missingIntroducedPath = compiled.stages.flatMap((stage) => stage.introducedFiles).find((filePath) => !includedPaths.includes(filePath));
+      if (missingIntroducedPath) {
+        throw new Error(`Deconstructed tour file is not renderable: ${missingIntroducedPath}`);
+      }
+      const introducedPaths = new Set(compiled.stages.flatMap((stage) => stage.introducedFiles));
       let totalContentBytes = 0;
-      const files = includedPaths.map((filePath) => {
+      const files = includedPaths.flatMap((filePath) => {
         const states = [
           compiled.baselineFiles.find((file) => file.path === filePath),
           ...compiled.stages.map((stage) => stage.files.find((file) => file.path === filePath))
@@ -5230,18 +6458,23 @@ var require_changeTour = __commonJS({
         if (states.some((state) => !state)) {
           throw new Error(`Deconstructed scene ${source.id} is missing virtual state for ${filePath}.`);
         }
-        return {
+        const fileContentBytes = states.reduce((total, state) => total + Buffer.byteLength((state == null ? void 0 : state.content) || "", "utf8"), 0);
+        const exceedsFileLimit = states.some((state) => {
+          const content = Buffer.from((state == null ? void 0 : state.content) || "", "utf8");
+          return content.length > DEFAULT_MAX_TOUR_FILE_BYTES || hasLineLongerThan(content, DEFAULT_MAX_TOUR_LINE_BYTES);
+        });
+        const exceedsSceneLimit = totalContentBytes + fileContentBytes > DEFAULT_MAX_STACK_CONTENT_BYTES;
+        if (exceedsFileLimit || exceedsSceneLimit) {
+          if (introducedPaths.has(filePath)) {
+            throw new Error(exceedsFileLimit ? `Deconstructed tour file is too large to present: ${filePath}` : `Deconstructed tour content exceeds ${DEFAULT_MAX_STACK_CONTENT_BYTES} bytes.`);
+          }
+          return [];
+        }
+        totalContentBytes += fileContentBytes;
+        return [{
           path: filePath,
           panels: states.map((state, index) => {
             if (!state) throw new Error(`Missing virtual state for ${filePath}.`);
-            const content = Buffer.from(state.content, "utf8");
-            if (content.length > DEFAULT_MAX_TOUR_FILE_BYTES || hasLineLongerThan(content, DEFAULT_MAX_TOUR_LINE_BYTES)) {
-              throw new Error(`Deconstructed tour file is too large to present: ${filePath}`);
-            }
-            totalContentBytes += content.length;
-            if (totalContentBytes > DEFAULT_MAX_STACK_CONTENT_BYTES) {
-              throw new Error(`Deconstructed tour content exceeds ${DEFAULT_MAX_STACK_CONTENT_BYTES} bytes.`);
-            }
             return {
               id: panels[index].id,
               label: `${panels[index].label} / ${filePath}${state.exists ? "" : " (absent)"}`,
@@ -5250,9 +6483,10 @@ var require_changeTour = __commonJS({
               exists: state.exists
             };
           })
-        };
+        }];
       });
       if (files.length === 0) throw new Error(`Deconstructed scene ${source.id} has no staged files.`);
+      const steps = buildDeconstructedFocusSteps(source.id, compiled.stages, files);
       return {
         id: source.id,
         kind: "deconstructed-diff",
@@ -5270,17 +6504,63 @@ var require_changeTour = __commonJS({
         },
         panels,
         files,
-        steps: compiled.stages.map((stage, index) => ({
-          id: stage.id,
-          title: stage.title,
-          body: stage.narration,
-          file: stage.introducedFiles[0],
-          pairIndex: index,
-          side: "right",
-          introducedHunks: stage.introducedHunks
-        }))
+        steps
       };
     }
+    function buildDeconstructedFocusSteps(sceneId, stages, files) {
+      const reservedIds = new Set(stages.map((stage) => stage.id));
+      const usedIds = /* @__PURE__ */ new Set();
+      return stages.flatMap((stage, stageIndex) => {
+        const focuses = stage.introducedChanges.flatMap((change) => {
+          const file = files.find((candidate) => candidate.path === change.file);
+          const left = file == null ? void 0 : file.panels[stageIndex];
+          const right = file == null ? void 0 : file.panels[stageIndex + 1];
+          if (!file || !left || !right) {
+            throw new Error(`Deconstructed scene ${sceneId} is missing comparison state for ${change.file}.`);
+          }
+          const diffModel = buildTwoWayDiffModel3(left.content, right.content);
+          const side = left.exists && !right.exists ? "left" : "right";
+          const ranges = buildTourFocusRanges(diffModel, side);
+          if (ranges.length === 0) {
+            throw new Error(`Deconstructed stage ${stage.id} has no visible change for ${change.file}.`);
+          }
+          return ranges.map((range) => ({
+            file: change.file,
+            hunks: change.hunks,
+            side,
+            ...range
+          }));
+        });
+        return focuses.map((focus, focusIndex) => ({
+          id: focusIndex === 0 ? claimDeconstructedStageId(stage.id, usedIds) : claimDeconstructedFocusId(`${stage.id}-focus-${focusIndex + 1}`, reservedIds, usedIds),
+          title: focuses.length === 1 ? stage.title : `${stage.title} \xB7 ${focus.file} \xB7 Focus ${focusIndex + 1}/${focuses.length}`,
+          body: stage.narration,
+          file: focus.file,
+          pairIndex: stageIndex,
+          side: focus.side,
+          startLine: focus.startLine,
+          endLine: focus.endLine,
+          introducedHunks: [...focus.hunks],
+          stageId: stage.id,
+          stageIndex,
+          focusIndex,
+          focusCount: focuses.length
+        }));
+      });
+    }
+    function claimDeconstructedStageId(stageId, usedIds) {
+      usedIds.add(stageId);
+      return stageId;
+    }
+    function claimDeconstructedFocusId(preferredId, reservedIds, usedIds) {
+      let candidate = preferredId;
+      let suffix = 2;
+      while (usedIds.has(candidate) || reservedIds.has(candidate)) {
+        candidate = `${preferredId}-${suffix++}`;
+      }
+      usedIds.add(candidate);
+      return candidate;
+    }
     function buildStackedScene(repoRoot, source, availableFilePaths) {
       const stack = source.stack.map((entry) => ({
         id: entry.id,
@@ -9297,7 +10577,7 @@ var require_package = __commonJS({
       displayName: "Bygone",
       desktopName: "com.davidmashburn.bygone.desktop",
       description: "See how change happened. Visual diff and file history for VS Code.",
-      version: "0.8.11",
+      version: "0.8.13",
       author: "David Mashburn",
       license: "MIT",
       private: false,