opencode-gbk-tools 0.1.26 → 0.1.28

package/dist/opencode-tools/text_edit.js

@@ -16576,35 +16576,126 @@ function buildNoMatchMessage(content, oldString) {
   assertStringArgument2(oldString, "oldString");
   return [
     "\u672A\u627E\u5230\u9700\u8981\u66FF\u6362\u7684\u6587\u672C\u3002",
-    "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\u3002",
+    "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\uFF0C\u6216\u4EC5\u5728\u6362\u884C/\u5C3E\u968F\u7A7A\u884C\u4E0A\u5B58\u5728\u8F7B\u5FAE\u5DEE\u5F02\u3002",
     "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFF1A",
     getNearestContext(content, oldString)
   ].join("\n");
 }
-function findOccurrenceIndex(text, token, occurrence) {
+function trimRightSpaces(text) {
   assertStringArgument2(text, "text");
-  assertStringArgument2(token, "anchor");
-  assertPositiveInteger(occurrence, "occurrence");
+  return text.replace(/[ \t]+$/g, "");
+}
+function splitNormalizedLines(text) {
+  return normalizeNewlines(text).split("\n");
+}
+function trimTrailingEmptyLines(lines) {
+  const result = [...lines];
+  while (result.length > 0 && trimRightSpaces(result[result.length - 1]) === "") {
+    result.pop();
+  }
+  return result;
+}
+function hasLineNumberPrefixes(lines) {
+  const nonEmpty = lines.filter((line) => line.trim().length > 0);
+  return nonEmpty.length > 0 && nonEmpty.every((line) => /^\d+: /.test(line));
+}
+function stripLineNumberPrefixes(lines) {
+  return lines.map((line) => line.replace(/^\d+: /, ""));
+}
+function parseLineNumberPrefixedBlock(text) {
+  const normalizedText = normalizeNewlines(text);
+  const hasTrailingNewline = normalizedText.endsWith("\n");
+  const lines = trimTrailingEmptyLines(splitNormalizedLines(text));
+  if (lines.length === 0 || !hasLineNumberPrefixes(lines)) {
+    return null;
+  }
+  const lineNumbers = [];
+  const strippedLines = [];
+  for (const line of lines) {
+    const match = /^(\d+): ?(.*)$/.exec(line);
+    if (!match) {
+      return null;
+    }
+    lineNumbers.push(Number(match[1]));
+    strippedLines.push(match[2]);
+  }
+  return {
+    lineNumbers,
+    strippedText: `${strippedLines.join("\n")}${hasTrailingNewline ? "\n" : ""}`,
+    isContiguous: lineNumbers.every((lineNumber, index) => index === 0 || lineNumber === lineNumbers[index - 1] + 1),
+    startLine: lineNumbers[0],
+    endLine: lineNumbers[lineNumbers.length - 1]
+  };
+}
+function collectOccurrencePositions(text, token) {
   if (token.length === 0) {
-    throw createTextError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+    return [];
   }
-  let count = 0;
+  const positions = [];
   let searchFrom = 0;
   while (true) {
     const index = text.indexOf(token, searchFrom);
     if (index === -1) {
-      break;
-    }
-    count += 1;
-    if (count === occurrence) {
-      return { index, total: countOccurrences(text, token) };
+      return positions;
     }
+    positions.push(index);
     searchFrom = index + token.length;
   }
-  if (count === 0) {
+}
+function buildFlexibleSearchVariants(token, newlineStyle) {
+  const variants = /* @__PURE__ */ new Set();
+  const pushVariant = (value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      return;
+    }
+    variants.add(value);
+  };
+  pushVariant(token);
+  pushVariant(alignTextToNewlineStyle(token, newlineStyle));
+  const prefixedBlock = parseLineNumberPrefixedBlock(token);
+  if (prefixedBlock) {
+    pushVariant(prefixedBlock.strippedText);
+    pushVariant(alignTextToNewlineStyle(prefixedBlock.strippedText, newlineStyle));
+  }
+  const trimmedLines = trimTrailingEmptyLines(splitNormalizedLines(token));
+  if (trimmedLines.length > 0) {
+    const trimmedToken = trimmedLines.join("\n");
+    pushVariant(trimmedToken);
+    pushVariant(alignTextToNewlineStyle(trimmedToken, newlineStyle));
+    const trimmedPrefixedBlock = parseLineNumberPrefixedBlock(trimmedToken);
+    if (trimmedPrefixedBlock) {
+      pushVariant(trimmedPrefixedBlock.strippedText);
+      pushVariant(alignTextToNewlineStyle(trimmedPrefixedBlock.strippedText, newlineStyle));
+    }
+  }
+  return [...variants];
+}
+function findOccurrenceIndex(text, token, occurrence, newlineStyle) {
+  assertStringArgument2(text, "text");
+  assertStringArgument2(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let maxMatches = 0;
+  for (const candidate of buildFlexibleSearchVariants(token, newlineStyle)) {
+    const positions = collectOccurrencePositions(text, candidate);
+    if (positions.length === 0) {
+      continue;
+    }
+    maxMatches = Math.max(maxMatches, positions.length);
+    if (positions.length >= occurrence) {
+      return {
+        index: positions[occurrence - 1],
+        total: positions.length,
+        matchedToken: candidate
+      };
+    }
+  }
+  if (maxMatches === 0) {
     throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
   }
-  throw createTextError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${count} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${occurrence} \u5904`);
+  throw createTextError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${maxMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${occurrence} \u5904`);
 }
 function assertInsertArguments(input) {
   assertStringArgument2(input.anchor, "anchor");
@@ -16656,8 +16747,8 @@ function buildLineDiffPreview(filePath, encoding, beforeText, afterText) {
 }
 function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, newlineStyle) {
   const alignedContent = alignTextToNewlineStyle(content, newlineStyle);
-  const located = findOccurrenceIndex(text, anchor, occurrence);
-  const insertionPoint = mode === "insertAfter" ? located.index + anchor.length : located.index;
+  const located = findOccurrenceIndex(text, anchor, occurrence, newlineStyle);
+  const insertionPoint = mode === "insertAfter" ? located.index + located.matchedToken.length : located.index;
   const alreadyExists = mode === "insertAfter" ? text.slice(insertionPoint, insertionPoint + alignedContent.length) === alignedContent : text.slice(Math.max(0, insertionPoint - alignedContent.length), insertionPoint) === alignedContent;
   if (alreadyExists) {
     if (ifExists === "error") {
@@ -16671,8 +16762,8 @@ function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, ne
         anchorMatches: located.total,
         occurrence,
         anchor,
-        previewBefore: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + anchor.length + 80)),
-        previewAfter: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + anchor.length + 80))
+        previewBefore: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + located.matchedToken.length + 80)),
+        previewAfter: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + located.matchedToken.length + 80))
       };
     }
   }
@@ -16779,6 +16870,150 @@ async function detectReadableTextFile(input) {
     hasBom: detected.hasBom
   };
 }
+async function visitDecodedTextChunks(resolved, visitor) {
+  const stream = createReadStream2(resolved.filePath);
+  const bomLength = getBomPrefix(resolved.encoding, resolved.hasBom).length;
+  const decoderEncoding = resolved.encoding === "utf8-bom" ? "utf8" : resolved.encoding;
+  const decoder = import_iconv_lite2.default.getDecoder(decoderEncoding);
+  let skippedBom = false;
+  try {
+    for await (const chunk of stream) {
+      let buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (!skippedBom && bomLength > 0) {
+        buffer = buffer.subarray(Math.min(bomLength, buffer.length));
+        skippedBom = true;
+      } else {
+        skippedBom = true;
+      }
+      if (buffer.length === 0) {
+        continue;
+      }
+      const text = decoder.write(buffer);
+      if (text.length > 0) {
+        await visitor(text);
+      }
+    }
+    const trailingText = decoder.end() ?? "";
+    if (trailingText.length > 0) {
+      await visitor(trailingText);
+    }
+  } catch (error45) {
+    if (error45 instanceof Error && "code" in error45) {
+      throw error45;
+    }
+    throw createTextError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${resolved.filePath}`, error45);
+  } finally {
+    stream.destroy();
+  }
+}
+async function writeLargeTextFile(filePath, encoding, hasBom, producer) {
+  const tempPath = path3.join(path3.dirname(filePath), `${path3.basename(filePath)}.opencode-text-${crypto2.randomUUID()}.tmp`);
+  const handle = await fs3.open(tempPath, "w");
+  try {
+    if (hasBom) {
+      const bom = getBomPrefix(encoding, hasBom);
+      if (bom.length > 0) {
+        await handle.writeFile(bom);
+      }
+    }
+    const bytesWritten = await producer(handle);
+    await handle.close();
+    await fs3.rename(tempPath, filePath);
+    return bytesWritten + getBomPrefix(encoding, hasBom).length;
+  } catch (error45) {
+    await handle.close().catch(() => void 0);
+    await fs3.rm(tempPath, { force: true }).catch(() => void 0);
+    throw error45;
+  }
+}
+async function writeEncodedTextChunk(handle, encoding, text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  const buffer = encodeTextBody(text, encoding);
+  await handle.writeFile(buffer);
+  return buffer.byteLength;
+}
+async function replaceLargeTextFileText(input) {
+  const carryLength = Math.max(input.oldString.length - 1, 0);
+  const fileNewlineStyle = input.loaded.newlineStyle;
+  const alignedNewString = fileNewlineStyle === "crlf" ? input.newString.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : fileNewlineStyle === "lf" ? input.newString.replace(/\r\n/g, "\n") : input.newString;
+  let carry = "";
+  let occurrencesBefore = 0;
+  let replacedFirstMatch = false;
+  const bytesWritten = await writeLargeTextFile(input.loaded.filePath, input.loaded.encoding, input.loaded.hasBom, async (handle) => {
+    let written = 0;
+    const flushText = async (text, flush = false) => {
+      const combined = carry + text;
+      if (combined.length === 0) {
+        return;
+      }
+      const safeEnd = flush ? combined.length : Math.max(0, combined.length - carryLength);
+      const outputParts = [];
+      let cursor = 0;
+      let flushUpto = safeEnd;
+      while (true) {
+        const index = combined.indexOf(input.oldString, cursor);
+        if (index === -1) {
+          break;
+        }
+        const matchEnd = index + input.oldString.length;
+        if (!flush && matchEnd > safeEnd) {
+          flushUpto = index;
+          break;
+        }
+        occurrencesBefore += 1;
+        outputParts.push(combined.slice(cursor, index));
+        if (input.replaceAll) {
+          outputParts.push(alignedNewString);
+        } else if (!replacedFirstMatch) {
+          outputParts.push(alignedNewString);
+          replacedFirstMatch = true;
+        } else {
+          outputParts.push(input.oldString);
+        }
+        cursor = matchEnd;
+      }
+      outputParts.push(combined.slice(cursor, flushUpto));
+      carry = combined.slice(flushUpto);
+      const processable = outputParts.join("");
+      if (processable.length === 0) {
+        return;
+      }
+      written += await writeEncodedTextChunk(handle, input.loaded.encoding, processable);
+    };
+    await visitDecodedTextChunks({
+      filePath: input.loaded.filePath,
+      encoding: input.loaded.encoding,
+      hasBom: input.loaded.hasBom
+    }, async (text) => {
+      await flushText(text);
+    });
+    await flushText("", true);
+    if (occurrencesBefore === 0) {
+      throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${input.oldString}`);
+    }
+    if (!input.replaceAll && occurrencesBefore > 1) {
+      throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
+    }
+    return written;
+  });
+  return {
+    mode: "replace",
+    filePath: input.loaded.filePath,
+    encoding: input.loaded.encoding,
+    requestedEncoding: input.loaded.requestedEncoding,
+    detectedEncoding: input.loaded.detectedEncoding,
+    confidence: input.loaded.confidence,
+    hasBom: input.loaded.hasBom,
+    replacements: input.replaceAll ? occurrencesBefore : 1,
+    occurrencesBefore,
+    bytesRead: input.loaded.bytesRead,
+    bytesWritten,
+    newlineStyle: input.loaded.newlineStyle,
+    diffPreview: void 0
+  };
+}
 async function readWholeTextFile(input) {
   const resolved = await resolveReadableTextFile(input);
   try {
@@ -16857,19 +17092,14 @@ function applyAnchors(text, startAnchor, endAnchor) {
   }
   let rangeStart = 0;
   let rangeEnd = text.length;
+  const newlineStyle = detectNewlineStyle(text);
   if (startAnchor) {
-    const found = text.indexOf(startAnchor);
-    if (found === -1) {
-      throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8D77\u59CB\u951A\u70B9: ${startAnchor}`);
-    }
-    rangeStart = found + startAnchor.length;
+    const found = findOccurrenceIndex(text, startAnchor, 1, newlineStyle);
+    rangeStart = found.index + found.matchedToken.length;
   }
   if (endAnchor) {
-    const found = text.indexOf(endAnchor, rangeStart);
-    if (found === -1) {
-      throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u7ED3\u675F\u951A\u70B9: ${endAnchor}`);
-    }
-    rangeEnd = found;
+    const found = findOccurrenceIndex(text.slice(rangeStart), endAnchor, 1, newlineStyle);
+    rangeEnd = rangeStart + found.index;
   }
   if (rangeEnd < rangeStart) {
     throw createTextError("GBK_INVALID_ARGUMENT", "\u951A\u70B9\u8303\u56F4\u65E0\u6548");
@@ -16900,6 +17130,64 @@ function alignTextToNewlineStyle(text, newlineStyle) {
   }
   return text;
 }
+function matchLooseBlock(contentLines, oldLines, newLines, newlineStyle) {
+  for (let start = 0; start < contentLines.length; start += 1) {
+    let contentIndex = start;
+    let oldIndex = 0;
+    while (oldIndex < oldLines.length && contentIndex < contentLines.length) {
+      const expected = trimRightSpaces(oldLines[oldIndex]);
+      const actual = trimRightSpaces(contentLines[contentIndex]);
+      if (expected === actual) {
+        oldIndex += 1;
+        contentIndex += 1;
+        continue;
+      }
+      if (actual === "") {
+        contentIndex += 1;
+        continue;
+      }
+      if (expected === "") {
+        oldIndex += 1;
+        continue;
+      }
+      break;
+    }
+    if (oldIndex === oldLines.length) {
+      const matchedOriginal = contentLines.slice(start, contentIndex).join("\n");
+      const replacedNormalized = [
+        ...contentLines.slice(0, start),
+        ...newLines,
+        ...contentLines.slice(contentIndex)
+      ].join("\n");
+      return {
+        occurrencesBefore: 1,
+        matchedOriginal,
+        content: newlineStyle === "crlf" ? replacedNormalized.replace(/\n/g, "\r\n") : replacedNormalized
+      };
+    }
+  }
+  return null;
+}
+function tryLooseBlockReplace(content, oldString, newString) {
+  const contentLines = splitNormalizedLines(content);
+  const oldLines = trimTrailingEmptyLines(splitNormalizedLines(oldString));
+  const newLines = splitNormalizedLines(newString);
+  const newlineStyle = detectNewlineStyle(content);
+  if (oldLines.length === 0) {
+    return null;
+  }
+  const direct = matchLooseBlock(contentLines, oldLines, newLines, newlineStyle);
+  if (direct !== null) {
+    return direct;
+  }
+  if (hasLineNumberPrefixes(oldLines)) {
+    const strippedOldLines = trimTrailingEmptyLines(stripLineNumberPrefixes(oldLines));
+    if (strippedOldLines.length > 0) {
+      return matchLooseBlock(contentLines, strippedOldLines, newLines, newlineStyle);
+    }
+  }
+  return null;
+}
 function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
   assertStringArgument2(input, "content");
   const buffer = encodeText(input, encoding, hasBom);
@@ -16981,37 +17269,89 @@ async function replaceTextFileText(input) {
   if (input.oldString.length === 0) {
     throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
   }
+  const prefixedBlock = parseLineNumberPrefixedBlock(input.oldString);
+  const derivedScopedRange = prefixedBlock?.isContiguous ? {
+    startLine: normalizedInput.startLine ?? prefixedBlock.startLine,
+    endLine: normalizedInput.endLine ?? prefixedBlock.endLine,
+    oldString: prefixedBlock.strippedText
+  } : null;
+  const effectiveOldString = derivedScopedRange?.oldString ?? input.oldString;
   const resolved = await detectReadableTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
+  const hasScopedRange = normalizedInput.startLine !== void 0 || normalizedInput.endLine !== void 0 || normalizedInput.startAnchor !== void 0 || normalizedInput.endAnchor !== void 0 || derivedScopedRange !== null;
+  const preserveEncoding = normalizedInput.preserveEncoding ?? true;
+  const preserveNewlineStyle = normalizedInput.preserveNewlineStyle ?? true;
+  const requestedEncoding = normalizedInput.encoding ?? "auto";
+  if (resolved.stat.size >= TEXT_STREAMING_FILE_SIZE_THRESHOLD_BYTES && !hasScopedRange && preserveEncoding && preserveNewlineStyle && requestedEncoding === "auto") {
+    const loadedForStreaming = await readWholeTextFile({
+      filePath: input.filePath,
+      encoding: requestedEncoding,
+      allowExternal: input.allowExternal,
+      context: input.context
+    });
+    return await replaceLargeTextFileText({
+      loaded: loadedForStreaming,
+      oldString: effectiveOldString,
+      newString: input.newString,
+      replaceAll: normalizedInput.replaceAll ?? false
+    });
+  }
   const loaded = await readWholeTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
-  const scope = resolveEditScope(loaded.content, normalizedInput);
+  const scopedInput = derivedScopedRange === null ? normalizedInput : {
+    ...normalizedInput,
+    startLine: derivedScopedRange.startLine,
+    endLine: derivedScopedRange.endLine
+  };
+  const scope = resolveEditScope(loaded.content, scopedInput);
   const replaceAll = normalizedInput.replaceAll ?? false;
-  const preserveEncoding = normalizedInput.preserveEncoding ?? true;
-  const requestedEncoding = normalizedInput.encoding ?? "auto";
-  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
+  const targetEncoding = preserveEncoding || requestedEncoding === "auto" ? loaded.encoding : resolveExplicitTextEncoding(requestedEncoding, loaded.encoding);
+  const targetHasBom = preserveEncoding ? loaded.hasBom : targetEncoding === "utf8-bom" || targetEncoding === "utf16le" || targetEncoding === "utf16be";
+  const occurrencesBefore = countOccurrences(scope.selectedText, effectiveOldString);
+  if (!replaceAll && occurrencesBefore === 0) {
+    const loose = tryLooseBlockReplace(scope.selectedText, effectiveOldString, input.newString);
+    if (loose !== null) {
+      const outputText2 = `${loaded.content.slice(0, scope.rangeStart)}${loose.content}${loaded.content.slice(scope.rangeEnd)}`;
+      ensureLossless(outputText2, targetEncoding, targetHasBom);
+      const buffer2 = encodeText(outputText2, targetEncoding, targetHasBom);
+      await fs3.writeFile(loaded.filePath, buffer2);
+      return {
+        mode: "replace",
+        filePath: loaded.filePath,
+        encoding: targetEncoding,
+        requestedEncoding: loaded.requestedEncoding,
+        detectedEncoding: loaded.detectedEncoding,
+        confidence: loaded.confidence,
+        hasBom: targetHasBom,
+        replacements: 1,
+        occurrencesBefore: loose.occurrencesBefore,
+        bytesRead: loaded.bytesRead,
+        bytesWritten: buffer2.byteLength,
+        newlineStyle: detectNewlineStyle(outputText2),
+        diffPreview: buildLineDiffPreview(loaded.filePath, targetEncoding, loose.matchedOriginal, input.newString)
+      };
+    }
+  }
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
+      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, effectiveOldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
+    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, effectiveOldString));
   } else if (occurrencesBefore > 1) {
-    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
+    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${effectiveOldString}`);
   }
   const alignedNewString = normalizedInput.preserveNewlineStyle === false ? input.newString : alignTextToNewlineStyle(input.newString, loaded.newlineStyle);
-  const replaced = replaceAll ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
+  const replaced = replaceAll ? scope.selectedText.split(effectiveOldString).join(alignedNewString) : scope.selectedText.replace(effectiveOldString, alignedNewString);
   const outputText = `${loaded.content.slice(0, scope.rangeStart)}${replaced}${loaded.content.slice(scope.rangeEnd)}`;
-  const targetEncoding = preserveEncoding || requestedEncoding === "auto" ? loaded.encoding : resolveExplicitTextEncoding(requestedEncoding, loaded.encoding);
-  const targetHasBom = preserveEncoding ? loaded.hasBom : targetEncoding === "utf8-bom" || targetEncoding === "utf16le" || targetEncoding === "utf16be";
   ensureLossless(outputText, targetEncoding, targetHasBom);
   const buffer = encodeText(outputText, targetEncoding, targetHasBom);
   await fs3.writeFile(loaded.filePath, buffer);
@@ -17028,7 +17368,7 @@ async function replaceTextFileText(input) {
     bytesRead: loaded.bytesRead,
     bytesWritten: buffer.byteLength,
     newlineStyle: detectNewlineStyle(outputText),
-    diffPreview: buildLineDiffPreview(loaded.filePath, targetEncoding, input.oldString, alignedNewString)
+    diffPreview: buildLineDiffPreview(loaded.filePath, targetEncoding, effectiveOldString, alignedNewString)
   };
 }