pi-hashline-edit-pro 4.4.3 → 4.5.0

package/src/line-endings.ts

@@ -0,0 +1,151 @@
+import type { LineEnding } from "./normalize";
+
+export interface EndingSpan {
+	start: number;
+	end: number;
+	replacementCount: number;
+}
+
+export function countNewlines(content: string): number {
+	let count = 0;
+	for (let index = 0; index < content.length; index++) {
+		if (content.charCodeAt(index) === 10) count += 1;
+	}
+	return count;
+}
+
+export function splitSeparators(raw: string): LineEnding[] {
+	const separators: LineEnding[] = [];
+	for (let index = 0; index < raw.length; index++) {
+		const char = raw[index]!;
+		if (char === "\r") {
+			if (raw[index + 1] === "\n") {
+				separators.push("\r\n");
+				index += 1;
+			} else {
+				separators.push("\r");
+			}
+		} else if (char === "\n") {
+			separators.push("\n");
+		}
+	}
+	return separators;
+}
+
+export function joinSeparators(content: string, separators: readonly LineEnding[]): string {
+	let out = "";
+	let separatorIndex = 0;
+	for (const char of content) {
+		if (char === "\n") {
+			out += separators[separatorIndex] ?? "\n";
+			separatorIndex += 1;
+		} else {
+			out += char;
+		}
+	}
+	return out;
+}
+
+function sourceLineMap(baseLineCount: number, spans: readonly EndingSpan[]): number[] {
+	const sorted = [...spans].sort((left, right) => left.start - right.start);
+	const map: number[] = [];
+	let baseLine = 0;
+	for (const span of sorted) {
+		while (baseLine < span.start && baseLine < baseLineCount) {
+			map.push(baseLine);
+			baseLine += 1;
+		}
+		const spanLength = span.end >= span.start ? span.end - span.start + 1 : 0;
+		for (let offset = 0; offset < span.replacementCount; offset++) {
+			if (offset < spanLength) map.push(span.start + offset);
+			else map.push(spanLength > 0 ? span.end : span.start - 1);
+		}
+		baseLine = span.end >= span.start ? span.end + 1 : span.start;
+	}
+	while (baseLine < baseLineCount) {
+		map.push(baseLine);
+		baseLine += 1;
+	}
+	return map;
+}
+
+export function separatorsForSpans(
+	baseSeparators: readonly LineEnding[],
+	baseLineCount: number,
+	spans: readonly EndingSpan[],
+	resultContent: string,
+	fallback: LineEnding,
+): LineEnding[] {
+	const mapped = sourceLineMap(baseLineCount, spans).map((source) =>
+		source >= 0 && source < baseSeparators.length ? baseSeparators[source]! : "",
+	);
+	const needed = countNewlines(resultContent);
+	const result: LineEnding[] = [];
+	for (let index = 0; index < needed; index++) {
+		const candidate = mapped[index];
+		if (candidate !== undefined && candidate !== "") result.push(candidate);
+		else result.push(result[index - 1] ?? fallback);
+	}
+	return result;
+}
+
+export function endingsForRange(separators: readonly LineEnding[], startLine: number, endLine: number): (LineEnding | undefined)[] {
+	const endings: (LineEnding | undefined)[] = [];
+	for (let line = startLine; line <= endLine; line += 1) {
+		endings.push(separators[line - 1]);
+	}
+	return endings;
+}
+
+export function splitWithEndings(text: string): { lines: string[]; endings: (LineEnding | undefined)[] } {
+	const lines: string[] = [];
+	const endings: (LineEnding | undefined)[] = [];
+	let current = "";
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index]!;
+		if (char === "\r") {
+			const crlf = text[index + 1] === "\n";
+			endings.push(crlf ? "\r\n" : "\r");
+			lines.push(current);
+			current = "";
+			if (crlf) index += 1;
+			continue;
+		}
+		if (char === "\n") {
+			endings.push("\n");
+			lines.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	lines.push(current);
+	endings.push(undefined);
+	return { lines, endings };
+}
+
+export function applyEndingOverrides(separators: LineEnding[], spanStart: number, endings: readonly (LineEnding | undefined)[] | undefined): void {
+	if (endings === undefined) return;
+	for (let index = 0; index < endings.length; index += 1) {
+		const ending = endings[index];
+		if (ending === undefined) continue;
+		const target = spanStart + index;
+		if (target >= 0 && target < separators.length) separators[target] = ending;
+	}
+}
+
+export function applySpanEndings(separators: LineEnding[], spans: readonly { start: number; end: number; replacementCount: number; endings?: (LineEnding | undefined)[] }[]): void {
+	const sorted = [...spans].sort((left, right) => left.start - right.start);
+	let offset = 0;
+	for (const span of sorted) {
+		if (span.endings !== undefined) {
+			for (let index = 0; index < span.endings.length; index += 1) {
+				const ending = span.endings[index];
+				if (ending === undefined) continue;
+				const target = span.start + offset + index;
+				if (target >= 0 && target < separators.length) separators[target] = ending;
+			}
+		}
+		offset += span.replacementCount - (span.end - span.start + 1);
+	}
+}

package/src/paths.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { isAbsolute, relative, resolve as resolvePath, join, dirname } from "node:path";
+import { isAbsolute, relative, resolve as resolvePath, join, dirname, parse } from "node:path";
 
 
 function homeBase(): string {
@@ -16,7 +16,11 @@ function configBase(): string {
 }
 
 export function configDir(): string {
-  return join(configBase(), "pi-hashline-edit-pro");
+  const override = process.env.PI_HASHLINE_DIR;
+  if (override && !isAbsolute(override)) {
+    throw new Error("[E_CONFIG] PI_HASHLINE_DIR must be an absolute path");
+  }
+  return override || join(configBase(), "pi-hashline-edit-pro");
 }
 
 export function configPath(): string {
@@ -51,6 +55,22 @@ export function toCwd(filePath: string, cwd: string): string {
   return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
 }
 
+function pathDepth(path: string): number {
+  const root = parse(path).root;
+  return path.slice(root.length).split(/[\\/]+/).filter((part) => part.length > 0).length;
+}
+
+function climbsToRoot(cwd: string, relativePath: string): boolean {
+  let climbs = 0;
+  for (const part of relativePath.split("/")) {
+    if (part !== "..") break;
+    climbs += 1;
+  }
+  return climbs > 0 && climbs >= pathDepth(resolvePath(cwd));
+}
+
 export function toDisplayPath(cwd: string, absolutePath: string, fallback?: string): string {
-  return relative(cwd, absolutePath).replace(/\\/g, "/") || (fallback ?? absolutePath);
+  const rel = relative(cwd, absolutePath).replace(/\\/g, "/");
+  if (rel.length === 0 || climbsToRoot(cwd, rel)) return fallback ?? absolutePath;
+  return rel;
 }

package/src/payload-contract.ts

@@ -4,7 +4,7 @@ import { isRec, normalizeRequest, rejectUnknownFields, assertNoNul } from "./uti
 const replacementLinesSchema = Type.Array(
   Type.String({
     description:
-      "One replacement line; never embed \\n inside an element.",
+      "One replacement line. A real line break (\\n, \\r\\n, or \\r) splits it into lines and sets their endings; escape sequences are not decoded.",
   }),
   {
     description:
@@ -131,3 +131,31 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
   }
   assertNoNul(request.lines);
 }
+
+const TRANSFER_KEYS = new Set(["path", "source_from", "source_to", "insert_after"]);
+
+export interface TransferReq {
+  path?: string;
+  source_from: string;
+  source_to: string;
+  insert_after: string;
+}
+
+export function assertTransferReq(request: unknown): asserts request is TransferReq {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Copy/move request must be an object.");
+  }
+  rejectUnknownFields(request, TRANSFER_KEYS, "Copy/move request");
+  if (request.path !== undefined && typeof request.path !== "string") {
+    throw new Error('[E_BAD_SHAPE] Copy/move request field "path" must be a string when provided.');
+  }
+  if (typeof request.source_from !== "string" || request.source_from.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Copy/move request requires a "source_from" string (4-char anchor from read output).');
+  }
+  if (typeof request.source_to !== "string" || request.source_to.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Copy/move request requires a "source_to" string (4-char anchor from read output).');
+  }
+  if (typeof request.insert_after !== "string" || request.insert_after.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Copy/move request requires an "insert_after" string (4-char anchor from read output).');
+  }
+}

package/src/read.ts

@@ -19,7 +19,7 @@ import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-
 import { valAccess } from "./validation";
 import { readConfig } from "./config";
 import { resolveTarget } from "./fs-write";
-import { withAnchorSession, servedForPath, sessionKeyFor } from "./anchor-registry";
+import { withAnchorSession, servedForPath, sessionKeyFor, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { serveRows } from "./served";
 import { getAutoReadAllSnapshot } from "./auto-read-all-state";
 import { Text } from "@earendil-works/pi-tui";
@@ -258,10 +258,12 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 				);
 				serveRows(resolvedPath, fileHashes, fileLines, preview.servedHashes);
 				const snapshotId = await safeSnapId(absolutePath, "read");
-				const previewText =
-					hadUtf8DecodeErrors
-						? `${preview.text}\n\n[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]`
-						: preview.text;
+				const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
+				const previewText = [
+					preview.text,
+					hadUtf8DecodeErrors ? "[Non-UTF-8 bytes shown as U+FFFD; editing rewrites the file as UTF-8.]" : undefined,
+					reclaimNotice,
+				].filter((part): part is string => part !== undefined).join("\n\n");
 
 				return {
 					content: [{ type: "text", text: previewText }],

package/src/replace-render.ts

@@ -81,7 +81,7 @@ export function highlightBatchRefs(text: string, theme: FgT): string {
 }
 
 export function fmtCall(
-  args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | undefined,
+  args: { path?: string; remove_from?: string; remove_to?: string; anchor?: string; source_from?: string; source_to?: string; insert_after?: string } | undefined,
   state: RRState,
   expanded: boolean,
   theme: CallT,
@@ -89,7 +89,7 @@ export function fmtCall(
 ): string {
   const previewPath = state.preview && "path" in state.preview ? state.preview.path : undefined;
   const path = args?.path ?? state.resolvedPath ?? previewPath;
-  const anchorFallback = typeof args?.remove_from === "string" && typeof args?.remove_to === "string" ? `${args.remove_from}→${args.remove_to}` : typeof args?.anchor === "string" ? args.anchor : undefined;
+  const anchorFallback = typeof args?.remove_from === "string" && typeof args?.remove_to === "string" ? `${args.remove_from}→${args.remove_to}` : typeof args?.anchor === "string" ? args.anchor : typeof args?.source_from === "string" && typeof args?.insert_after === "string" ? `${args.source_from}→${args.insert_after}` : undefined;
   const pathDisplay =
     typeof path === "string" && path.length > 0
       ? theme.fg("accent", path)
@@ -264,9 +264,9 @@ export function reuseMarkdown(context: any, content: string, theme: any): Markdo
 export function makeRenderCall(
 	preview: (args: unknown, cwd: string, signal?: AbortSignal) => Promise<RPreview>,
   options: {
-    getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string } | null;
+    getInput?: (args: unknown) => { path?: string; remove_from?: string; remove_to?: string; anchor?: string; source_from?: string; source_to?: string; insert_after?: string } | null;
     toolName?: string;
-    resolveTarget?: (input: { remove_from?: string; remove_to?: string; anchor?: string }) => string | undefined;
+    resolveTarget?: (input: { remove_from?: string; remove_to?: string; anchor?: string; source_from?: string; source_to?: string; insert_after?: string }) => string | undefined;
   } = {},
 ) {
 	const getInput = options.getInput ?? getPreviewInput;

package/src/replace-undo.ts

@@ -6,9 +6,10 @@ import { Type } from "typebox";
 import { loadHashStore, persistSnapshot, upsertUndo, getUndoEntry, deleteUndo, type UndoRecord } from "./hash-store";
 import { servedHashesFromDiff, serveRows } from "./served";
 import { lineChecksum } from "./hashline";
-import { freeAnchors, adoptAnchors, withAnchorSession } from "./anchor-registry";
+import { freeAnchors, adoptAnchors, withAnchorSession, formatAnchorReclaimNotice, takeReclaimedPaths } from "./anchor-registry";
 import { resolveInCwd, writeAtomic, type FileIdentity } from "./fs-write";
 import { toLF, stripBOM, restoreEndings, type LineEnding } from "./normalize";
+import { joinSeparators } from "./line-endings";
 import { genDiff, genPatch, spansFromHashes } from "./replace-diff";
 import { getDiffContextLines } from "./config";
 import { cntDiff, errCode, makePrepareArguments, splitLines } from "./utils";
@@ -22,8 +23,10 @@ export interface UndoEntry {
   content: string;
   bom: string;
   originalEnding: LineEnding;
+  separators?: LineEnding[];
   hashes: string[];
   resultContent: string;
+  resultSeparators?: LineEnding[];
   mode?: number;
 }
 
@@ -44,8 +47,10 @@ export async function saveUndo(
       content: entry.content,
       bom: entry.bom,
       ending: entry.originalEnding,
+      ...(entry.separators !== undefined ? { separators: entry.separators } : {}),
       hashes: entry.hashes,
       resultContent: entry.resultContent,
+      ...(entry.resultSeparators !== undefined ? { resultSeparators: entry.resultSeparators } : {}),
       ...(mode !== undefined ? { mode } : {}),
     });
   } catch (error) {
@@ -80,8 +85,10 @@ export async function getUndo(path: string): Promise<UndoEntry | undefined> {
       content: record.content,
       bom: record.bom,
       originalEnding,
+      ...(record.separators !== undefined ? { separators: record.separators as LineEnding[] } : {}),
       hashes: record.hashes,
       resultContent: record.resultContent,
+      ...(record.resultSeparators !== undefined ? { resultSeparators: record.resultSeparators as LineEnding[] } : {}),
       ...(record.mode !== undefined ? { mode: record.mode } : {}),
     };
   } catch (error) {
@@ -171,7 +178,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 
           if (
             currentRaw !== undefined &&
-            currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)
+            currentRaw !== undo.bom + (undo.resultSeparators !== undefined ? joinSeparators(undo.resultContent, undo.resultSeparators) : restoreEndings(undo.resultContent, undo.originalEnding))
           ) {
             return {
               content: [
@@ -187,7 +194,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 
           await writeAtomic(
             mutationTargetPath,
-            undo.bom + restoreEndings(undo.content, undo.originalEnding),
+            undo.bom + (undo.separators !== undefined ? joinSeparators(undo.content, undo.separators) : restoreEndings(undo.content, undo.originalEnding)),
             currentIdentity,
             undo.mode ?? fallbackFileMode(),
           );
@@ -237,6 +244,8 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
           parts.push(
             "Call read for fresh anchors.",
           );
+          const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
+          if (reclaimNotice !== undefined) parts.push(reclaimNotice);
 
           const patchResult = genPatch(path, currentNormalized, undo.content);
           return {
@@ -255,7 +264,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
                 classification: "applied",
                 editsAttempted: 1,
                 noopEditsCount: 0,
-                warningsCount: 0,
+                warningsCount: reclaimNotice !== undefined ? 1 : 0,
                 firstChangedLine: restoredRange?.firstChangedLine,
                 lastChangedLine: restoredRange?.lastChangedLine,
                 addedLines: linesRemovedByReplace,

package/src/replace.ts

@@ -10,7 +10,7 @@ import {
 } from "./replace-diff";
 import { readNormFile, type NormFile } from "./file-reader";
 import { editToolSchema, buildEditToolSchema, type ReqParams, assertReq, normReq } from "./payload-contract";
-import { splitLines } from "./utils";
+import { literalEscapeWarning, splitLines } from "./utils";
 import { loadP, loadGuide } from "./prompts";
 import { type FileIdentity } from "./fs-write";
 import { applyEdit,
@@ -21,6 +21,7 @@ import { applyEdit,
   AnchorMismatchError,
   type HEdit,
   type NEdit,
+  type StripWarningLocation,
 } from "./hashline";
 import { type RMetrics } from "./replace-response";
 import {
@@ -56,6 +57,7 @@ export interface PipelineResult {
   result: string;
   bom: string;
   originalEnding: LineEnding;
+  originalSeparators: LineEnding[];
   hadUtf8DecodeErrors: boolean;
   warnings: string[];
   noopEdit?: NEdit;
@@ -67,6 +69,7 @@ export interface PipelineResult {
   totalRemovedLines: number;
   identity: FileIdentity;
   spans?: DiffSpan[];
+  contentSeparators?: (LineEnding | undefined)[];
 }
 
 
@@ -76,6 +79,9 @@ export interface ExecPipelineOptions {
   store?: HashStore;
   noPersist?: boolean;
   preloadedNorm?: NormFile;
+  served?: ReadonlyMap<string, string>;
+  allowEmpty?: boolean;
+  stripWarning?: StripWarningLocation;
 }
 
 export function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
@@ -91,7 +97,7 @@ export function spanForEdit(originalHashes: string[], from: string, to: string,
   const replacementCount = splitLines(resultContent).length - (originalHashes.length - (span[1] - span[0] + 1));
   return { start: span[0], end: span[1], replacementCount };
 }
-async function noteAnchorError(absolutePath: string, error: unknown, noPersist?: boolean): Promise<void> {
+export async function noteAnchorError(absolutePath: string, error: unknown, noPersist?: boolean): Promise<void> {
   if (noPersist === true) return;
   if (error instanceof RangeStaleError) {
     adoptAnchors(absolutePath, error.rangeServedMap);
@@ -137,8 +143,8 @@ export async function execPipeline(
   const { edit, warnings: editWarnings } = buildReplaceHEdit(params);
   const hashStore = options?.store ?? await loadHashStore();
   const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
-  const served = servedForPath(preResolvedPath);
-  const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
+  const served = options?.served ?? servedForPath(preResolvedPath);
+  const { normalized: originalNormalized, bom, originalEnding, endingSeparators: originalSeparators, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath, identity } = await readNormFile(
     targetPath, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore, noPersist: options?.noPersist, allocation: options?.noPersist ? "shadow" : "real", preloadedNorm: options?.preloadedNorm },
   );
   const displayPath = toDisplayPath(cwd, absolutePath, targetPath);
@@ -152,6 +158,8 @@ export async function execPipeline(
       originalHashes,
       displayPath,
       served,
+      options?.allowEmpty,
+      options?.stripWarning,
     );
   } catch (error) {
     await noteAnchorError(absolutePath, error, options?.noPersist);
@@ -181,6 +189,7 @@ export async function execPipeline(
     result,
     bom,
     originalEnding,
+    originalSeparators,
     hadUtf8DecodeErrors,
     warnings,
     noopEdit: anchorResult.noopEdit,
@@ -192,6 +201,7 @@ export async function execPipeline(
     totalRemovedLines,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
+    ...(edit.content_separators !== undefined ? { contentSeparators: edit.content_separators } : {}),
   };
 }
 
@@ -263,6 +273,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
         const canonical = normReq(params);
         assertReq(canonical);
         const normalizedParams = canonical;
+        const literalEscape = literalEscapeWarning(normalizedParams.replacement_lines, "replacement_lines");
         const targetPath = await resolveEditTargetWithRequirement({
           removeFrom: normalizedParams.remove_from,
           removeTo: normalizedParams.remove_to,
@@ -287,6 +298,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
               absolutePath,
               mutationTargetPath,
               editAnchors: [normalizedParams.remove_from, normalizedParams.remove_to],
+              prefixWarnings: literalEscape !== undefined ? [literalEscape] : [],
               signal,
             });
           }
@@ -305,7 +317,7 @@ export function buildToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): ToolDef
             cwd: ctx.cwd,
             signal,
             hedit: built.edit,
-            extraWarnings: built.warnings,
+            extraWarnings: [...(literalEscape !== undefined ? [literalEscape] : []), ...built.warnings],
           });
         });
       });

package/src/utils.ts

@@ -342,10 +342,6 @@ export function decodeStringArray(value: unknown, warnings?: string[], label = "
 	return undefined;
 }
 
-function splitEditLines(text: string): string[] {
-	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-}
-
 function normalizeLineFieldValue(value: unknown): string[] | undefined {
 	const candidate = typeof value === "string"
 		? value
@@ -356,7 +352,7 @@ function normalizeLineFieldValue(value: unknown): string[] | undefined {
 	const decoded = decodeStringArray(candidate);
 	if (decoded !== undefined) return decoded;
 	if (/^\[\s*\]$/.test(stripTrailingMemberCall(stripCodeFence(candidate)))) return [];
-	return splitEditLines(candidate);
+	return [candidate];
 }
 
 function normalizeEditLines(record: Record<string, unknown>): void {
@@ -366,3 +362,42 @@ function normalizeEditLines(record: Record<string, unknown>): void {
 		if (lines !== undefined) record[key] = lines;
 	}
 }
+
+const LITERAL_ESCAPE_RE = /\\(?:u([0-9a-fA-F]{4})|([ntr"]))/g;
+
+const REAL_LINE_BREAK_RE = /[\n\r]/;
+
+function isSurrogateEscapePair(line: string, index: number, hex: string): boolean {
+	const code = Number.parseInt(hex, 16);
+	if (code >= 0xd800 && code <= 0xdbff) {
+		const next = /^\\u([0-9a-fA-F]{4})/.exec(line.slice(index + 6))?.[1];
+		if (next === undefined) return false;
+		const nextCode = Number.parseInt(next, 16);
+		return nextCode >= 0xdc00 && nextCode <= 0xdfff;
+	}
+	if (code >= 0xdc00 && code <= 0xdfff) {
+		const previous = /\\u([0-9a-fA-F]{4})$/.exec(line.slice(0, index))?.[1];
+		if (previous === undefined) return false;
+		const previousCode = Number.parseInt(previous, 16);
+		return previousCode >= 0xd800 && previousCode <= 0xdbff;
+	}
+	return false;
+}
+
+export function literalEscapeWarning(lines: string[], label: string): string | undefined {
+	for (const line of lines) {
+		if (!line.includes("\\")) continue;
+		const hasRealBreak = REAL_LINE_BREAK_RE.test(line);
+		for (const match of line.matchAll(LITERAL_ESCAPE_RE)) {
+			const hex = match[1];
+			const simple = match[2];
+			if (simple !== undefined && hasRealBreak) continue;
+			if (hex !== undefined) {
+				if (hex.toLowerCase() === "dddd") continue;
+				if (isSurrogateEscapePair(line, match.index, hex)) continue;
+			}
+			return `[W_LITERAL_ESCAPE] "${label}" contains the literal escape text "${match[0]}"`;
+		}
+	}
+	return undefined;
+}