pi-hashline-edit-pro 0.9.8 → 0.11.0

package/src/hashline/apply.ts

@@ -1,26 +1,26 @@
-import { throwIfAborted } from "../runtime";
-import { computeLineHashes } from "./hash";
+import { abortIf } from "../runtime";
+import { lineHashes } from "./hash";
 import {
-	validateAnchorEdits,
-	assertNoBareHashPrefixLines,
-	maybeWarnSuspiciousUnicodeEscapePlaceholder,
-	formatMismatchError,
-	describeEdit,
-	type ResolvedHashlineEdit,
-	type NoopEdit,
-	type HashlineEdit,
-	type BoundaryDuplicationWarning,
+	valEdits,
+	assertNoBarePrefix,
+	warnUnicodeEsc,
+	fmtMismatch,
+	descEdit,
+	type RHEdit,
+	type NEdit,
+	type HEdit,
+	type BDupWarn,
 } from "./resolve";
-import { countVisibleLines } from "../utils";
-import { ANCHOR_CONTEXT_LINES, ANCHOR_MAX_OUTPUT_LINES } from "../constants";
+import { cntLines } from "../utils";
+import { CTX_LINES, MAX_OUT } from "../constants";
 
-type LineIndex = {
+type LIdx = {
 	fileLines: string[];
 	lineStarts: number[];
 	hasTerminalNewline: boolean;
 };
 
-export function buildLineIndex(content: string): LineIndex {
+export function buildIdx(content: string): LIdx {
 	const fileLines = content.split("\n");
 	const lineStarts: number[] = [];
 	let offset = 0;
@@ -40,8 +40,7 @@ export function buildLineIndex(content: string): LineIndex {
 	};
 }
 
-
-type ResolvedEditSpan = {
+type RESpan = {
 	kind: "replace";
 	index: number;
 	label: string;
@@ -50,7 +49,7 @@ type ResolvedEditSpan = {
 	replacement: string;
 };
 
-function assertDoesNotEmptyFile(originalContent: string, result: string): void {
+function assertNotEmpty(originalContent: string, result: string): void {
 	if (originalContent.length > 0 && result.length === 0) {
 		throw new Error(
 			"[E_WOULD_EMPTY] Cannot empty a non-empty file via edit."
@@ -58,8 +57,7 @@ function assertDoesNotEmptyFile(originalContent: string, result: string): void {
 	}
 }
 
-
-function throwEditConflict(
+function throwConflict(
 	left: { index: number; label: string },
 	right: { index: number; label: string },
 	reason: string,
@@ -69,14 +67,13 @@ function throwEditConflict(
 	);
 }
 
-
-function resolveEditToSpan(
-	edit: ResolvedHashlineEdit,
+function resToSpan(
+	edit: RHEdit,
 	index: number,
 	content: string,
-	lineIndex: LineIndex,
-	noopEdits: NoopEdit[],
-): ResolvedEditSpan | null {
+	lineIndex: LIdx,
+	noopEdits: NEdit[],
+): RESpan | null {
 	const { fileLines, lineStarts, hasTerminalNewline } = lineIndex;
 
 	const startLine = edit.old_range[0].line;
@@ -100,7 +97,7 @@ function resolveEditToSpan(
 		return {
 			kind: "replace",
 			index,
-			label: describeEdit(edit),
+			label: descEdit(edit),
 			start: lineStarts[startLine - 1]!,
 			end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
 			replacement: edit.new_lines.join("\n"),
@@ -111,7 +108,7 @@ function resolveEditToSpan(
 		return {
 			kind: "replace",
 			index,
-			label: describeEdit(edit),
+			label: descEdit(edit),
 			start: 0,
 			end: content.length,
 			replacement: "",
@@ -122,7 +119,7 @@ function resolveEditToSpan(
 		return {
 			kind: "replace",
 			index,
-			label: describeEdit(edit),
+			label: descEdit(edit),
 			start: lineStarts[startLine - 1]!,
 			end: lineStarts[endLine]!,
 			replacement: "",
@@ -132,14 +129,14 @@ function resolveEditToSpan(
 	return {
 		kind: "replace",
 		index,
-		label: describeEdit(edit),
+		label: descEdit(edit),
 		start: Math.max(0, lineStarts[startLine - 1]! - 1),
 		end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
 		replacement: "",
 	};
 }
 
-function assertNoConflictingSpans(spans: ResolvedEditSpan[]): void {
+function assertNoConflict(spans: RESpan[]): void {
 	for (let leftIndex = 0; leftIndex < spans.length; leftIndex++) {
 		const left = spans[leftIndex]!;
 		for (
@@ -150,7 +147,7 @@ function assertNoConflictingSpans(spans: ResolvedEditSpan[]): void {
 			const right = spans[rightIndex]!;
 
 			if (left.start < right.end && right.start < left.end) {
-				throwEditConflict(
+				throwConflict(
 					left,
 					right,
 					"overlap on the same original line range",
@@ -160,18 +157,18 @@ function assertNoConflictingSpans(spans: ResolvedEditSpan[]): void {
 	}
 }
 
-function resolveEditSpans(
-	edits: ResolvedHashlineEdit[],
+function resSpans(
+	edits: RHEdit[],
 	content: string,
-	lineIndex: LineIndex,
-	noopEdits: NoopEdit[],
+	lineIndex: LIdx,
+	noopEdits: NEdit[],
 	signal: AbortSignal | undefined,
-): ResolvedEditSpan[] {
+): RESpan[] {
 	const seenSpanKeys = new Set<string>();
-	const resolvedSpans: ResolvedEditSpan[] = [];
+	const resolvedSpans: RESpan[] = [];
 	for (const [index, edit] of edits.entries()) {
-		throwIfAborted(signal);
-		const span = resolveEditToSpan(
+	abortIf(signal);
+		const span = resToSpan(
 			edit,
 			index,
 			content,
@@ -191,7 +188,7 @@ function resolveEditSpans(
 		resolvedSpans.push(span);
 	}
 
-	assertNoConflictingSpans(resolvedSpans);
+	assertNoConflict(resolvedSpans);
 	return [...resolvedSpans].sort((left, right) => {
 		if (right.end !== left.end) {
 			return right.end - left.end;
@@ -200,24 +197,23 @@ function resolveEditSpans(
 	});
 }
 
-function assembleEditResult(
+function assemble(
 	content: string,
-	spans: ResolvedEditSpan[],
+	spans: RESpan[],
 	signal: AbortSignal | undefined,
 ): string {
 	let result = content;
 	for (const span of spans) {
-		throwIfAborted(signal);
+		abortIf(signal);
 		result =
 			result.slice(0, span.start) + span.replacement + result.slice(span.end);
 	}
 	return result;
 }
 
-
-export function applyHashlineEdits(
+export function applyEdits(
 	content: string,
-	edits: import("./resolve").HashlineEdit[],
+	edits: import("./resolve").HEdit[],
 	signal?: AbortSignal,
 	precomputedHashes?: string[],
 ): {
@@ -225,9 +221,9 @@ export function applyHashlineEdits(
 	firstChangedLine: number | undefined;
 	lastChangedLine: number | undefined;
 	warnings?: string[];
-	noopEdits?: NoopEdit[];
+	noopEdits?: NEdit[];
 } {
-	throwIfAborted(signal);
+	abortIf(signal);
 	if (!edits.length)
 		return {
 			content,
@@ -242,12 +238,12 @@ export function applyHashlineEdits(
 			: edit,
 	);
 
-	const lineIndex = buildLineIndex(content);
-	const fileHashes = precomputedHashes ?? computeLineHashes(content);
-	const noopEdits: NoopEdit[] = [];
+	const lineIndex = buildIdx(content);
+	const fileHashes = precomputedHashes ?? lineHashes(content);
+	const noopEdits: NEdit[] = [];
 	const warnings: string[] = [];
 
-	const { resolved, mismatches, boundaryWarnings } = validateAnchorEdits(
+	const { resolved, mismatches, boundaryWarnings } = valEdits(
 		edits,
 		lineIndex.fileLines,
 		fileHashes,
@@ -256,15 +252,15 @@ export function applyHashlineEdits(
 	);
 	if (mismatches.length) {
 		throw new Error(
-			formatMismatchError(mismatches, lineIndex.fileLines, fileHashes),
+			fmtMismatch(mismatches, lineIndex.fileLines, fileHashes),
 		);
 	}
 
-	const barePrefixWarnings = assertNoBareHashPrefixLines(edits, lineIndex.fileLines, fileHashes);
+	const barePrefixWarnings = assertNoBarePrefix(edits, lineIndex.fileLines, fileHashes);
 	warnings.push(...barePrefixWarnings);
-	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);
+	warnUnicodeEsc(edits, warnings);
 
-	const orderedSpans = resolveEditSpans(
+	const orderedSpans = resSpans(
 		resolved,
 		content,
 		lineIndex,
@@ -272,12 +268,12 @@ export function applyHashlineEdits(
 		signal,
 	);
 
-	const result = assembleEditResult(content, orderedSpans, signal);
-	assertDoesNotEmptyFile(content, result);
-	const changedRange = computeChangedLineRange(content, result);
+	const result = assemble(content, orderedSpans, signal);
+	assertNotEmpty(content, result);
+	const range = changedRange(content, result);
 
 	const resultLines = result.split("\n");
-	const resultHashes = computeLineHashes(result);
+	const resultHashes = lineHashes(result);
 	for (const bw of boundaryWarnings) {
 		let seen = 0;
 		let matchIndex = -1;
@@ -303,15 +299,14 @@ export function applyHashlineEdits(
 
 	return {
 		content: result,
-		firstChangedLine: changedRange?.firstChangedLine,
-		lastChangedLine: changedRange?.lastChangedLine,
+		firstChangedLine: range?.firstChangedLine,
+		lastChangedLine: range?.lastChangedLine,
 		...(warnings.length ? { warnings } : {}),
 		...(noopEdits.length ? { noopEdits } : {}),
 	};
 }
 
-
-export function computeAffectedLineRange(params: {
+export function affRange(params: {
 	firstChangedLine: number | undefined;
 	lastChangedLine: number | undefined;
 	resultLineCount: number;
@@ -322,8 +317,8 @@ export function computeAffectedLineRange(params: {
 		firstChangedLine,
 		lastChangedLine,
 		resultLineCount,
-		contextLines = ANCHOR_CONTEXT_LINES,
-		maxOutputLines = ANCHOR_MAX_OUTPUT_LINES,
+		contextLines = CTX_LINES,
+		maxOutputLines = MAX_OUT,
 	} = params;
 
 	if (firstChangedLine === undefined || lastChangedLine === undefined) {
@@ -352,13 +347,13 @@ export function computeAffectedLineRange(params: {
 	return { start, end };
 }
 
-export function formatHashlineRegion(
+export function fmtRegion(
 	hashes: string[],
 	lines: string[],
 ): string {
 	if (hashes.length !== lines.length) {
 		throw new Error(
-			`formatHashlineRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
+			`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`,
 		);
 	}
 	return lines
@@ -366,25 +361,23 @@ export function formatHashlineRegion(
 		.join("\n");
 }
 
-
-export function computeChangedLineRange(
+export function changedRange(
 	original: string,
 	result: string,
 ): { firstChangedLine: number; lastChangedLine: number } | null {
 	if (original === result) return null;
 
-
 	if (original.length === 0) {
 		return {
 			firstChangedLine: 1,
-			lastChangedLine: countVisibleLines(result),
+			lastChangedLine: cntLines(result),
 		};
 	}
 
 	if (result.startsWith(original) && original.endsWith("\n")) {
 		return {
-			firstChangedLine: countVisibleLines(original) + 1,
-			lastChangedLine: countVisibleLines(result),
+			firstChangedLine: cntLines(original) + 1,
+			lastChangedLine: cntLines(result),
 		};
 	}
 
@@ -395,7 +388,6 @@ export function computeChangedLineRange(
 	}
 	if (firstDiff === minLen && original.length === result.length) return null;
 
-
 	let lastOrig = original.length - 1;
 	let lastRes = result.length - 1;
 	while (
@@ -407,7 +399,7 @@ export function computeChangedLineRange(
 		lastRes--;
 	}
 
-	function indexToLine(charIdx: number, text: string): number {
+	function idxToLine(charIdx: number, text: string): number {
 		let line = 1;
 		for (let i = 0; i < charIdx && i < text.length; i++) {
 			if (text[i] === "\n") line++;
@@ -415,10 +407,10 @@ export function computeChangedLineRange(
 		return line;
 	}
 
-	const firstChangedLine = indexToLine(firstDiff + 1, result);
+	const firstChangedLine = idxToLine(firstDiff + 1, result);
 	let lastChangedLine: number;
 	if (lastRes < firstDiff) {
-		lastChangedLine = result.length === 0 ? 1 : countVisibleLines(result);
+		lastChangedLine = result.length === 0 ? 1 : cntLines(result);
 	} else if (
 		firstDiff === 0 &&
 		original.length > 0 &&
@@ -426,8 +418,8 @@ export function computeChangedLineRange(
 	) {
 		lastChangedLine = firstChangedLine;
 	} else {
-		lastChangedLine = indexToLine(lastRes + 1, result);
+		lastChangedLine = idxToLine(lastRes + 1, result);
 	}
 
 	return { firstChangedLine, lastChangedLine };
-}
+}

package/src/hashline/hash.ts

@@ -1,82 +1,78 @@
 import xxhash from "xxhash-wasm";
 
+export const HASH_LEN = 3;
+export const ANCHOR_LEN = HASH_LEN;
 
-export const HASH_LENGTH = 3;
-export const HASH_PREFIX = "";
-export const ANCHOR_LENGTH = HASH_LENGTH;
-
-const HASH_ALPHABET =
+const ALPH =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-const HASH_ALPHABET_BITS = 6;
-const HASH_ALPHABET_MASK = (1 << HASH_ALPHABET_BITS) - 1;
-const HASH_ALPHABET_REGEX_SAFE = HASH_ALPHABET.replace(/-/g, "\\-");
-const HASH_ALPHABET_RE = new RegExp(`^[${HASH_ALPHABET_REGEX_SAFE}]+$`);
-export const HASH_CHARS_CLASS = `${HASH_PREFIX}[${HASH_ALPHABET_REGEX_SAFE}]{${HASH_LENGTH}}`;
-function hashToString(h: number): string {
-	const totalBits = HASH_LENGTH * HASH_ALPHABET_BITS;
+const ALPH_BITS = 6;
+const ALPH_MASK = (1 << ALPH_BITS) - 1;
+const ALPH_SAFE = ALPH.replace(/-/g, "\\-");
+const ALPH_RE = new RegExp(`^[${ALPH_SAFE}]+$`);
+export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
+
+function h2s(h: number): string {
+	const totalBits = HASH_LEN * ALPH_BITS;
 	const shift = 32 - totalBits;
 	let n = h >>> shift;
 	let out = "";
-	for (let j = 0; j < HASH_LENGTH; j++) {
+	for (let j = 0; j < HASH_LEN; j++) {
 		out +=
-			HASH_ALPHABET[
-				(n >>> ((HASH_LENGTH - 1 - j) * HASH_ALPHABET_BITS)) &
-					HASH_ALPHABET_MASK
+			ALPH[
+				(n >>> ((HASH_LEN - 1 - j) * ALPH_BITS)) &
+					ALPH_MASK
 			]!;
 	}
 	return out;
 }
 
-export const HASHLINE_PREFIX_RE = new RegExp(
-	`^\\s*(?:>>>|>>)?\\s*${HASH_CHARS_CLASS}│`,
+export const HL_PREFIX_RE = new RegExp(
+	`^\\s*(?:>>>|>>)?\\s*${HASH_CLASS}│`,
 );
-export const HASHLINE_PREFIX_PLUS_RE = new RegExp(
-	`^\\+\\s*${HASH_CHARS_CLASS}│`,
+export const HL_PREFIX_PLUS_RE = new RegExp(
+	`^\\+\\s*${HASH_CLASS}│`,
 );
 export const DIFF_MINUS_RE = /^-\s*\d+\s{4}/;
 
-export const HASHLINE_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CHARS_CLASS})│`);
-
-
+export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
 
 type Hasher = { h32(input: string, seed?: number): number };
-let hasherPromise: Promise<Hasher> | null = null;
-let hasherSync: Hasher | null = null;
+let hasherP: Promise<Hasher> | null = null;
+let hasher: Hasher | null = null;
 
-function getHasher(): Hasher {
-	if (hasherSync) return hasherSync;
+function getH(): Hasher {
+	if (hasher) return hasher;
 	throw new Error("xxhash-wasm not initialized yet. This should not happen.");
 }
 
-hasherPromise = xxhash().then((h) => {
-	hasherSync = h;
+hasherP = xxhash().then((h) => {
+	hasher = h;
 	return h;
 });
 
-export function ensureHasherReady(): Promise<Hasher> {
-	return hasherPromise!
+export function initHasher(): Promise<Hasher> {
+	return hasherP!
 }
 
 function xxh32(input: string, seed = 0): number {
-	return getHasher().h32(input, seed) >>> 0;
+	return getH().h32(input, seed) >>> 0;
 }
 
-
-function canonicalizeLine(line: string): string {
+function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
-export function computeLineHashes(content: string): string[] {
+export function lineHashes(content: string): string[] {
 	const lines = content.split("\n");
 	const hashes = new Array<string>(lines.length);
 	const assigned = new Set<string>();
 	for (let i = 0; i < lines.length; i++) {
-		const canonical = canonicalizeLine(lines[i]!);
-		let hash = hashToString(xxh32(canonical));
+		const c = canon(lines[i]!);
+		let hash = h2s(xxh32(c));
 		let retry = 0;
 		while (assigned.has(hash)) {
 			retry++;
-			hash = hashToString(xxh32(`${canonical}:R${retry}`));
+			hash = h2s(xxh32(`${c}:R${retry}`));
 		}
 		assigned.add(hash);
 		hashes[i] = hash;
@@ -84,18 +80,8 @@ export function computeLineHashes(content: string): string[] {
 	return hashes;
 }
 
-export function computeLineHash(idx: number, line: string): string {
-	const canonical = canonicalizeLine(line);
-	return hashToString(xxh32(canonical));
+export function lineHash(idx: number, line: string): string {
+	return h2s(xxh32(canon(line)));
 }
 
-export const HASH_FORMAT = {
-	prefix: HASH_PREFIX,
-	length: HASH_LENGTH,
-	anchorLength: ANCHOR_LENGTH,
-	bitsPerChar: HASH_ALPHABET_BITS,
-	alphabet: HASH_ALPHABET,
-};
-
-
-export { HASH_ALPHABET_RE };
+export { ALPH_RE };

package/src/hashline/index.ts

@@ -1,44 +1,40 @@
-
-
 export {
-	HASH_LENGTH,
-	HASH_PREFIX,
-	ANCHOR_LENGTH,
-	HASH_FORMAT,
-	HASH_CHARS_CLASS,
-	HASHLINE_PREFIX_RE,
-	HASHLINE_PREFIX_PLUS_RE,
+	HASH_LEN,
+	ANCHOR_LEN,
+	HASH_CLASS,
+	HL_PREFIX_RE,
+	HL_PREFIX_PLUS_RE,
 	DIFF_MINUS_RE,
-	HASHLINE_BARE_PREFIX_RE,
-	computeLineHashes,
-	computeLineHash,
-	ensureHasherReady,
+	HL_BARE_PREFIX_RE,
+	lineHashes,
+	lineHash,
+	initHasher,
 } from "./hash";
 
 export {
 	parseHashRef,
-	hashlineParseText,
+	parseText,
 	type Anchor,
 } from "./parse";
 
 export {
-	type ResolvedAnchor,
-	type HashlineEdit,
-	type ResolvedHashlineEdit,
-	type HashlineToolEdit,
-	type NoopEdit,
-	type BoundaryDuplicationWarning,
-	describeEdit,
-	resolveEditAnchors,
-	validateAnchorEdits,
-	assertNoBareHashPrefixLines,
-	formatMismatchError,
+	type RAnchor,
+	type HEdit,
+	type RHEdit,
+	type HTEdit,
+	type NEdit,
+	type BDupWarn,
+	descEdit,
+	resEdits,
+	valEdits,
+	assertNoBarePrefix,
+	fmtMismatch,
 } from "./resolve";
 
 export {
-	buildLineIndex,
-	applyHashlineEdits,
-	computeAffectedLineRange,
-	formatHashlineRegion,
-	computeChangedLineRange,
+	buildIdx,
+	applyEdits,
+	affRange,
+	fmtRegion,
+	changedRange,
 } from "./apply";

package/src/hashline/parse.ts

@@ -1,61 +1,61 @@
-
 import {
-	ANCHOR_LENGTH,
-	HASH_ALPHABET_RE,
-	HASH_CHARS_CLASS,
-	HASHLINE_PREFIX_PLUS_RE,
+	ANCHOR_LEN,
+	ALPH_RE,
+	HASH_CLASS,
+	HL_PREFIX_PLUS_RE,
 	DIFF_MINUS_RE,
 } from "./hash";
 
-
 export type Anchor = { hash: string };
 
-
-function diagnoseHashRef(ref: string): string {
+function diagRef(ref: string): string {
 	const trimmed = ref.trim();
 
 	if (!trimmed.length) {
-		return `[E_BAD_REF] Invalid anchor. Expected a 3-character base64 anchor (e.g. \"aB3\").`;
+		return `[E_BAD_REF] Invalid anchor. Expected a 3-char base64 anchor (e.g. "aB3").`;
 	}
 
 	if (/^\d+/.test(trimmed)) {
-		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. \"aB3\") — no line numbers or trailing content.`;
+		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3") — no line numbers or trailing content.`;
 	}
 
-	return `[E_BAD_REF] Invalid anchor \"${trimmed}\". Expected a 3-character base64 anchor (e.g. \"aB3\").`;
+	if (trimmed.includes("│")) {
+		return `[E_BAD_REF] Invalid anchor "${trimmed}". old_range must contain the 3-char hash only — remove everything from "│" onward.`;
+	}
+
+	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char base64 anchor (e.g. "aB3").`;
 }
 
-function parseAnchorRef(ref: string): Anchor {
+function parseRef(ref: string): Anchor {
 	const trimmed = ref.trim();
 
 	if (
-		trimmed.length === ANCHOR_LENGTH &&
-		HASH_ALPHABET_RE.test(trimmed)
+		trimmed.length === ANCHOR_LEN &&
+		ALPH_RE.test(trimmed)
 	) {
 		return { hash: trimmed };
 	}
 
-	throw new Error(diagnoseHashRef(ref));
+	throw new Error(diagRef(ref));
 }
 
-export const parseHashRef = parseAnchorRef;
-
+export const parseHashRef = parseRef;
 
-function assertNoDisplayPrefixes(lines: string[]): void {
+function assertNoPrefixes(lines: string[]): void {
 	for (const line of lines) {
 		if (!line.length) continue;
 		if (
-			HASHLINE_PREFIX_PLUS_RE.test(line) ||
+			HL_PREFIX_PLUS_RE.test(line) ||
 			DIFF_MINUS_RE.test(line)
 		) {
 			throw new Error(
-			`[E_INVALID_PATCH] \"lines\" must contain literal file content, not HASH| or diff prefixes. Offending line: ${JSON.stringify(line)}`
+			`[E_INVALID_PATCH] "lines" must contain literal file content, not HASH| or diff prefixes. Offending line: ${JSON.stringify(line)}`
 			);
 		}
 	}
 }
 
-export function hashlineParseText(edit: string[] | string | null): string[] {
+export function parseText(edit: string[] | string | null): string[] {
 	if (edit === null) return [];
 	const lines =
 		typeof edit === "string"
@@ -63,6 +63,6 @@ export function hashlineParseText(edit: string[] | string | null): string[] {
 					.replaceAll("\r", "")
 					.split("\n")
 			: edit;
-	assertNoDisplayPrefixes(lines);
+	assertNoPrefixes(lines);
 	return lines;
 }