Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

fix(chrome-ext): bind Google Docs corrections to exact text (#4788)

Elijah Potter4897e4576a36
diff --git a/packages/chrome-plugin/src/contentScript/googleDocs.ts b/packages/chrome-plugin/src/contentScript/googleDocs.ts
index 143ee8ef5..686ca3e1c 100644
--- a/packages/chrome-plugin/src/contentScript/googleDocs.ts
+++ b/packages/chrome-plugin/src/contentScript/googleDocs.ts
@@ -42,12 +42,22 @@ type GoogleDocsRectSegment = {
rect: GoogleDocsRectLayout;
};
+type OrdinaryPiece = ['copy' | 'gap', number, number, number, number];
+type OrdinaryMap = {
+ format: 'ordinary-utf16-v1';
+ source: 'logical' | 'rects';
+ window: [number, number];
+ pieces: OrdinaryPiece[];
+ // Independent exact paragraphs when visual order cannot prove one window.
+ regions?: Array<[number, number, number, number]>;
+};
+
type GoogleDocsCloneSnapshot = {
fragment: DocumentFragment;
text: string;
source: 'logical' | 'rects' | 'native';
nativeSnapshot?: string;
- nativeRuns?: Array<[number, number, number]>;
+ nativeRuns?: Array<[number, number, number]> | OrdinaryMap;
segmentCount: number;
signature: string;
};
@@ -138,14 +148,6 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
delete window.__harperGoogleDocsBridgeClient;
}
- function addSignatureToken(hash: number, token: string): number {
- let nextHash = hash;
- for (let index = 0; index < token.length; index += 1) {
- nextHash = (nextHash * 33 + token.charCodeAt(index)) >>> 0;
- }
- return nextHash;
- }
-
function normalizeGoogleDocsRectLabel(label: string): string {
const parts = label.split(' ');
let normalized = '';
@@ -357,25 +359,40 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
segments: GoogleDocsRectSegment[],
editor: HTMLElement,
): string {
- let hash = 5381;
- hash = addSignatureToken(hash, source);
- hash = addSignatureToken(hash, text);
- hash = addSignatureToken(hash, `${editor.scrollTop}:${editor.scrollLeft}:${segments.length}`);
+ const pages = Array.from(editor.querySelectorAll('.kix-page-paginated'));
+ const paragraphs = Array.from(editor.querySelectorAll('g[role="paragraph"]'));
+ return JSON.stringify([
+ source,
+ text,
+ editor.scrollTop,
+ editor.scrollLeft,
+ segments.map((segment) => [
+ segment.rect,
+ segment.text,
+ segment.rectNode.getAttribute('aria-label'),
+ segment.rectNode.getAttribute('data-font-css'),
+ pages.indexOf(segment.page!),
+ paragraphs.indexOf(segment.rectNode.closest('g[role="paragraph"]')!),
+ ]),
+ ]);
+ }
- for (const segment of segments) {
- hash = addSignatureToken(
- hash,
- `${Math.round(segment.rect.top)}:${Math.round(segment.rect.left)}:${Math.round(segment.rect.width)}:${Math.round(segment.rect.height)}:${segment.text}`,
- );
+ function nativeOrdinaryBoundaries(native: string): number[] {
+ // Trace UTF-16 boundaries through the existing CR conversion. Do not count
+ // code points or recover offsets by looking for the diagnostic text later.
+ const boundaries = [0];
+ for (let offset = 0; offset < native.length; offset += 1) {
+ if (native[offset] === '\r' && native[offset + 1] === '\n') offset += 1;
+ boundaries.push(offset + 1);
}
-
- return String(hash);
+ return boundaries;
}
function buildLogicalSnapshot(
editor: HTMLElement,
segments: GoogleDocsRectSegment[],
logicalText: string,
+ nativeSnapshot: string,
): GoogleDocsCloneSnapshot | null {
if (logicalText.length === 0 || segments.length === 0) {
return null;
@@ -383,6 +400,9 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
const fragment = document.createDocumentFragment();
const parts: string[] = [];
+ const pieces: OrdinaryPiece[] = [];
+ const nativeBoundaries = nativeOrdinaryBoundaries(nativeSnapshot);
+ let projectionCursor = 0;
let cursor = 0;
let previousText = '';
let currentLineBand: GoogleDocsLineBand | null = null;
@@ -404,17 +424,37 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
const sharesVisualLine: boolean =
currentLineBand != null && rectSharesGoogleDocsLineBand(segment.rect, currentLineBand);
- const normalizedGap = normalizeLogicalGap(
- skippedText,
- previousText,
- segment.text,
- sharesVisualLine,
- segment.rect,
- segments[index + 1]?.rect ?? null,
- );
+ const normalizedGap = /\n[^\S\n]*\n/u.test(skippedText)
+ ? skippedText
+ : normalizeLogicalGap(
+ skippedText,
+ previousText,
+ segment.text,
+ sharesVisualLine,
+ segment.rect,
+ segments[index + 1]?.rect ?? null,
+ );
appendText(fragment, parts, normalizedGap);
-
- fragment.appendChild(createCloneSpan(segment, segment.text));
+ pieces.push([
+ 'gap',
+ projectionCursor,
+ projectionCursor + normalizedGap.length,
+ nativeBoundaries[cursor],
+ nativeBoundaries[startAtCursor],
+ ]);
+ projectionCursor += normalizedGap.length;
+
+ const span = createCloneSpan(segment, segment.text);
+ span.setAttribute('data-harper-gdocs-native-start', String(nativeBoundaries[startAtCursor]));
+ fragment.appendChild(span);
+ pieces.push([
+ 'copy',
+ projectionCursor,
+ projectionCursor + segment.text.length,
+ nativeBoundaries[startAtCursor],
+ nativeBoundaries[startAtCursor + segment.text.length],
+ ]);
+ projectionCursor += segment.text.length;
parts.push(segment.text);
cursor = startAtCursor + segment.text.length;
previousText = segment.text;
@@ -430,12 +470,26 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
}
appendText(fragment, parts, trailingText);
+ pieces.push([
+ 'gap',
+ projectionCursor,
+ projectionCursor + trailingText.length,
+ nativeBoundaries[cursor],
+ nativeSnapshot.length,
+ ]);
const text = parts.join('');
return {
fragment,
text,
source: 'logical',
+ nativeSnapshot,
+ nativeRuns: {
+ format: 'ordinary-utf16-v1',
+ source: 'logical',
+ window: [0, nativeSnapshot.length],
+ pieces,
+ },
segmentCount: segments.length,
signature: computeSignature('logical', text, segments, editor),
};
@@ -519,13 +573,49 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
return ' ';
}
+ function findUniqueRectWindow(
+ logicalText: string,
+ segments: GoogleDocsRectSegment[],
+ ): number[] | null {
+ let unique: number[] | null = null;
+ let search = 0;
+ while (segments.length > 0 && search < logicalText.length) {
+ const first = logicalText.indexOf(segments[0].text, search);
+ if (first < 0) break;
+ search = first + 1;
+ const starts = [first];
+ let end = first + segments[0].text.length;
+ for (const segment of segments.slice(1)) {
+ const start = logicalText.indexOf(segment.text, end);
+ if (start < 0 || !canIgnoreLogicalGap(logicalText.slice(end, start))) break;
+ starts.push(start);
+ end = start + segment.text.length;
+ }
+ if (starts.length !== segments.length) continue;
+ // Count embedded and overlapping matches before paragraph boundaries.
+ // Synthesized spacing cannot distinguish two matching label sequences.
+ if (unique != null) return null;
+ unique = starts;
+ }
+ if (unique == null) return null;
+ const first = unique[0];
+ const end = unique[unique.length - 1] + segments[segments.length - 1].text.length;
+ return (first === 0 || logicalText[first - 1] === '\n') &&
+ (end === logicalText.length || logicalText[end] === '\n')
+ ? unique
+ : null;
+ }
+
function buildRectSnapshot(
editor: HTMLElement,
segments: GoogleDocsRectSegment[],
logicalText: string,
+ nativeSnapshot: string,
): GoogleDocsCloneSnapshot {
const fragment = document.createDocumentFragment();
const parts: string[] = [];
+ const emitted: Array<{ start: number; end: number; span: HTMLSpanElement }> = [];
+ let projectionCursor = 0;
let previousText = '';
let previousRect: GoogleDocsRectLayout | null = null;
let previousSegment: GoogleDocsRectSegment | null = null;
@@ -561,15 +651,20 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
? '\n\n'
: '\n';
appendText(fragment, parts, breakText);
+ projectionCursor += breakText.length;
} else if (
previousRect != null &&
(isStandaloneListMarker(previousText) ||
shouldInsertGoogleDocsSpace(previousRect, segment.rect, previousText, segment.text))
) {
appendText(fragment, parts, ' ');
+ projectionCursor += 1;
}
- fragment.appendChild(createCloneSpan(segment, segment.text));
+ const span = createCloneSpan(segment, segment.text);
+ fragment.appendChild(span);
+ emitted.push({ start: projectionCursor, end: projectionCursor + segment.text.length, span });
+ projectionCursor += segment.text.length;
parts.push(segment.text);
previousText = segment.text;
previousRect = segment.rect;
@@ -580,12 +675,104 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
: extendGoogleDocsLineBand(currentLineBand, segment.rect);
}
- const text = parts.join('');
+ let text = parts.join('');
+ // A fallback may omit whole offscreen paragraphs, never text inside its
+ // declared window. Prove occurrence identity with the actual labels/gaps.
+ const starts = findUniqueRectWindow(logicalText, segments);
+ const nativeRuns: OrdinaryMap = {
+ format: 'ordinary-utf16-v1',
+ source: 'rects',
+ window: [0, 0],
+ pieces: [],
+ };
+ if (starts != null) {
+ const boundaries = nativeOrdinaryBoundaries(nativeSnapshot);
+ let p = 0;
+ let n = boundaries[starts[0]];
+ nativeRuns.window[0] = n;
+ for (let index = 0; index < emitted.length; index += 1) {
+ const { start, end, span } = emitted[index];
+ const nativeStart = boundaries[starts[index]];
+ const nativeEnd = boundaries[starts[index] + segments[index].text.length];
+ nativeRuns.pieces.push(['gap', p, start, n, nativeStart]);
+ nativeRuns.pieces.push(['copy', start, end, nativeStart, nativeEnd]);
+ span.setAttribute('data-harper-gdocs-native-start', String(nativeStart));
+ p = end;
+ n = nativeEnd;
+ }
+ nativeRuns.window[1] = n;
+ } else {
+ const boundaries = nativeOrdinaryBoundaries(nativeSnapshot);
+ nativeRuns.regions = [];
+ for (let index = 0; index < segments.length; index += 1) {
+ // Retain the full-window label/gap contract here. Exact synthesized
+ // paragraph text can hide another candidate with different whitespace.
+ const first = index;
+ const group = segments[index].rectNode.closest('g[role="paragraph"]');
+ if (group != null) {
+ while (
+ index + 1 < segments.length &&
+ segments[index + 1].rectNode.closest('g[role="paragraph"]') === group
+ )
+ index += 1;
+ }
+ const p0 = emitted[first].start;
+ const p1 = emitted[index].end;
+ const label = text.slice(p0, p1);
+ const matches = findUniqueRectWindow(logicalText, segments.slice(first, index + 1));
+ if (matches == null) continue;
+ const match = matches[0];
+ const matchEnd = matches[matches.length - 1] + segments[index].text.length;
+ const start = boundaries[match];
+ const end = boundaries[matchEnd];
+ if (nativeSnapshot.slice(start, end) !== label) continue;
+ nativeRuns.regions.push([p0, p1, start, end]);
+ for (let part = first; part <= index; part += 1) {
+ emitted[part].span.setAttribute(
+ 'data-harper-gdocs-native-start',
+ String(start + emitted[part].start - p0),
+ );
+ }
+ }
+ // Only independently proven complete native paragraphs establish these
+ // breaks. Do not infer them from physical line/page spacing or change
+ // the existing projection of unproven text between other labels.
+ const regionSpans = nativeRuns.regions.map((region) => ({
+ region,
+ first: emitted.find((part) => part.start === region[0])!.span,
+ last: emitted.find((part) => part.end === region[1])!.span,
+ }));
+ for (const { first, last } of regionSpans) {
+ let prefix = '';
+ let suffix = '';
+ for (let node = first.previousSibling; node != null; node = node.previousSibling)
+ prefix = (node.textContent ?? '') + prefix;
+ for (let node = last.nextSibling; node != null; node = node.nextSibling)
+ suffix += node.textContent ?? '';
+ if (prefix.length > 0 && !/\n[^\S\n]*\n\s*$/u.test(prefix))
+ fragment.insertBefore(document.createTextNode('\n\n'), first);
+ if (suffix.length > 0 && !/^\s*\n[^\S\n]*\n/u.test(suffix))
+ fragment.insertBefore(document.createTextNode('\n\n'), last.nextSibling);
+ }
+ const offsets = new Map<Node, number>();
+ let offset = 0;
+ for (const node of Array.from(fragment.childNodes)) {
+ offsets.set(node, offset);
+ offset += node.textContent?.length ?? 0;
+ }
+ for (const { region, first, last } of regionSpans) {
+ region[0] = offsets.get(first)!;
+ region[1] = offsets.get(last)! + last.textContent!.length;
+ }
+ text = fragment.textContent ?? '';
+ }
return {
fragment,
text,
source: 'rects',
+ nativeSnapshot,
+ nativeRuns,
segmentCount: segments.length,
signature: computeSignature('rects', text, segments, editor),
};
@@ -813,16 +1000,20 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
: segments;
const logicalText = nativeText.replace(/\r\n?/gu, '\n');
return (
- buildLogicalSnapshot(editor, ordinarySegments, logicalText) ??
- buildRectSnapshot(editor, ordinarySegments, logicalText)
+ buildLogicalSnapshot(editor, ordinarySegments, logicalText, nativeText) ??
+ buildRectSnapshot(editor, ordinarySegments, logicalText, nativeText)
);
}
function applySnapshot(target: HTMLElement, snapshot: GoogleDocsCloneSnapshot): boolean {
const previousNative = target.getAttribute('data-harper-gdocs-native-snapshot');
+ const serializedRuns =
+ snapshot.nativeSnapshot != null ? JSON.stringify(snapshot.nativeRuns) : null;
if (
snapshot.signature === lastCloneSignature &&
target.textContent === snapshot.text &&
+ target.getAttribute('data-harper-gdocs-source') === snapshot.source &&
+ target.getAttribute('data-harper-gdocs-native-runs') === serializedRuns &&
previousNative === (snapshot.nativeSnapshot ?? null)
) {
return false;
@@ -831,7 +1022,7 @@ export function createGoogleDocsBridgeSync(fw: LintFramework): () => Promise<voi
target.replaceChildren(snapshot.fragment);
if (snapshot.nativeSnapshot != null) {
target.setAttribute('data-harper-gdocs-native-snapshot', snapshot.nativeSnapshot);
- target.setAttribute('data-harper-gdocs-native-runs', JSON.stringify(snapshot.nativeRuns));
+ target.setAttribute('data-harper-gdocs-native-runs', serializedRuns!);
} else {
target.removeAttribute('data-harper-gdocs-native-snapshot');
target.removeAttribute('data-harper-gdocs-native-runs');
diff --git a/packages/lint-framework/src/lint/LintFramework.ts b/packages/lint-framework/src/lint/LintFramework.ts
index fe41a61cd..f4fbf2221 100644
--- a/packages/lint-framework/src/lint/LintFramework.ts
+++ b/packages/lint-framework/src/lint/LintFramework.ts
@@ -406,9 +406,7 @@ export default class LintFramework {
if (!target) {
return [];
}
- const mapped =
- isGoogleDocsTarget(target) &&
- target.getAttribute('data-harper-gdocs-source') === 'native';
+ const mapped = isGoogleDocsTarget(target);
const { text, isCM } = this.getTargetText(target);
if (text == null) {
diff --git a/packages/lint-framework/src/lint/computeLintBoxes/googleDocsUtilities.ts b/packages/lint-framework/src/lint/computeLintBoxes/googleDocsUtilities.ts
index 62519c873..04b6d27b0 100644
--- a/packages/lint-framework/src/lint/computeLintBoxes/googleDocsUtilities.ts
+++ b/packages/lint-framework/src/lint/computeLintBoxes/googleDocsUtilities.ts
@@ -260,7 +260,9 @@ export function getGoogleDocsHighlightRects(target: HTMLElement, span: Span): DO
// Native gaps have text but no geometry. DOM Range on the hidden mirror
// would otherwise manufacture a box near the editor origin.
if (
- target.getAttribute('data-harper-gdocs-source') === 'native' &&
+ (target.getAttribute('data-harper-gdocs-source') === 'native' ||
+ target.hasAttribute('data-harper-gdocs-native-snapshot') ||
+ target.hasAttribute('data-harper-gdocs-native-runs')) &&
!positionedHost?.hasAttribute('data-harper-gdocs-native-start')
)
continue;
diff --git a/packages/lint-framework/src/lint/googleDocsAdapter.ts b/packages/lint-framework/src/lint/googleDocsAdapter.ts
index 9247028bb..98e77d2de 100644
--- a/packages/lint-framework/src/lint/googleDocsAdapter.ts
+++ b/packages/lint-framework/src/lint/googleDocsAdapter.ts
@@ -18,6 +18,173 @@ const GOOGLE_DOCS_SOFT_BREAKS = /\u000b/gu;
// biome-ignore lint/suspicious/noControlCharactersInRegex: Corrections must not cross native structural boundaries.
const GOOGLE_DOCS_CONTROL_CHARACTERS = /[\u0000-\u001f]/u;
+function splitsSurrogate(text: string, offset: number): boolean {
+ return (
+ offset > 0 &&
+ offset < text.length &&
+ text.charCodeAt(offset - 1) >= 0xd800 &&
+ text.charCodeAt(offset - 1) <= 0xdbff &&
+ text.charCodeAt(offset) >= 0xdc00 &&
+ text.charCodeAt(offset) <= 0xdfff
+ );
+}
+
+function resolveOrdinarySpan(
+ map: unknown,
+ sourceMode: string | null,
+ source: string,
+ native: string,
+ span: UnpackedSpan,
+): UnpackedSpan | null {
+ if (map == null || typeof map !== 'object' || Array.isArray(map)) return null;
+ const descriptor = map as {
+ format?: unknown;
+ source?: unknown;
+ window?: unknown;
+ pieces?: unknown;
+ regions?: unknown;
+ };
+ if (
+ descriptor.format !== 'ordinary-utf16-v1' ||
+ descriptor.source !== sourceMode ||
+ (sourceMode !== 'logical' && sourceMode !== 'rects')
+ )
+ return null;
+ const window = descriptor.window;
+ if (descriptor.regions !== undefined) {
+ if (
+ sourceMode !== 'rects' ||
+ !Array.isArray(descriptor.regions) ||
+ descriptor.regions.length === 0 ||
+ !Array.isArray(window) ||
+ window.length !== 2 ||
+ window[0] !== 0 ||
+ window[1] !== 0 ||
+ !Array.isArray(descriptor.pieces) ||
+ descriptor.pieces.length !== 0
+ )
+ return null;
+ let previousEnd = 0;
+ const nativeWindows: Array<[number, number]> = [];
+ let resolved: UnpackedSpan | null = null;
+ for (const region of descriptor.regions) {
+ if (!Array.isArray(region) || region.length !== 4 || !region.every(Number.isInteger))
+ return null;
+ const [p0, p1, n0, n1] = region;
+ if (
+ p0 < previousEnd ||
+ p1 <= p0 ||
+ p1 > source.length ||
+ nativeWindows.some(([start, end]) => start < n1 && end > n0)
+ )
+ return null;
+ // Independent regions prove complete exact paragraphs, not arbitrary
+ // omitted native gaps or a synthetic linguistic join between them.
+ const localSource = source.slice(p0, p1);
+ const valid = resolveOrdinarySpan(
+ {
+ format: descriptor.format,
+ source: sourceMode,
+ window: [n0, n1],
+ pieces: [['copy', 0, p1 - p0, n0, n1]],
+ },
+ sourceMode,
+ localSource,
+ native,
+ { start: 0, end: localSource.length },
+ );
+ if (valid == null) return null;
+ if (
+ span.start >= p0 &&
+ span.end <= p1 &&
+ // A complete native paragraph proves diagnostic context only when
+ // it is also isolated from unproven text in the lint projection.
+ (p0 === 0 || /\n[^\S\n]*\n\s*$/u.test(source.slice(0, p0))) &&
+ (p1 === source.length || /^\s*\n[^\S\n]*\n/u.test(source.slice(p1)))
+ )
+ resolved = { start: n0 + span.start - p0, end: n0 + span.end - p0 };
+ previousEnd = p1;
+ nativeWindows.push([n0, n1]);
+ }
+ return resolved;
+ }
+ if (
+ !Array.isArray(window) ||
+ window.length !== 2 ||
+ !window.every(Number.isInteger) ||
+ window[0] < 0 ||
+ window[1] <= window[0] ||
+ window[1] > native.length ||
+ !Array.isArray(descriptor.pieces) ||
+ descriptor.pieces.length === 0
+ )
+ return null;
+ if (
+ sourceMode === 'logical'
+ ? window[0] !== 0 || window[1] !== native.length
+ : (window[0] > 0 && !/[\r\n]/u.test(native[window[0] - 1])) ||
+ (window[1] < native.length && !/[\r\n]/u.test(native[window[1]]))
+ )
+ return null;
+ let p = 0;
+ let n = window[0];
+ let resolved: UnpackedSpan | null = null;
+ let copyStart: { projection: number; native: number } | null = null;
+ for (const piece of descriptor.pieces) {
+ if (!Array.isArray(piece) || piece.length !== 5 || !piece.slice(1).every(Number.isInteger))
+ return null;
+ const [kind, p0, p1, n0, n1] = piece;
+ if (p0 !== p || n0 !== n || p1 < p0 || n1 < n0 || p1 > source.length || n1 > native.length)
+ return null;
+ const projected = source.slice(p0, p1);
+ const original = native.slice(n0, n1);
+ if (kind === 'copy') {
+ if (p1 === p0 || projected !== original) return null;
+ copyStart ??= { projection: p0, native: n0 };
+ if (span.start >= copyStart.projection && span.end <= p1)
+ resolved = {
+ start: copyStart.native + span.start - copyStart.projection,
+ end: copyStart.native + span.end - copyStart.projection,
+ };
+ } else if (kind === 'gap') {
+ const normalized = original.replace(/\r\n?/gu, '\n');
+ if (
+ !/^\s*$/u.test(original) ||
+ (/\n[^\S\n]*\n/u.test(normalized) && !/\n[^\S\n]*\n/u.test(projected)) ||
+ !(
+ projected === normalized ||
+ (original === '' && projected === ' ') ||
+ projected === normalized.replace(/\n+/gu, '\n') ||
+ projected === normalized.replace(/\n+/gu, '\n\n')
+ )
+ )
+ return null;
+ // Exact native whitespace preserves the contiguous offset chain.
+ // Synthetic or normalized gaps cannot authorize a spanning edit.
+ if (projected !== original) copyStart = null;
+ } else return null;
+ p = p1;
+ n = n1;
+ }
+ if (sourceMode === 'rects') {
+ const comparable = native.replace(/\r\n?/gu, '\n');
+ const windowText = native.slice(window[0], window[1]).replace(/\r\n?/gu, '\n');
+ let matches = 0;
+ let cursor = 0;
+ while (cursor < comparable.length) {
+ const start = comparable.indexOf(windowText, cursor);
+ if (start < 0) break;
+ // Embedded and overlapping occurrences are ambiguous too, including
+ // when this window validates an independent paragraph region.
+ matches += 1;
+ if (matches > 1) return null;
+ cursor = start + 1;
+ }
+ if (matches !== 1) return null;
+ }
+ return p === source.length && n === window[1] ? resolved : null;
+}
+
function resolveNativeSpan(
target: HTMLElement,
source: string,
@@ -25,6 +192,14 @@ function resolveNativeSpan(
span: UnpackedSpan,
): UnpackedSpan | null {
const runs: unknown = JSON.parse(target.getAttribute('data-harper-gdocs-native-runs') ?? 'null');
+ if (target.getAttribute('data-harper-gdocs-source') !== 'native')
+ return resolveOrdinarySpan(
+ runs,
+ target.getAttribute('data-harper-gdocs-source'),
+ source,
+ nativeSnapshot,
+ span,
+ );
if (!Array.isArray(runs) || runs.length === 0) return null;
const masked = nativeSnapshot
.replace(GOOGLE_DOCS_TABLE_SEPARATORS, '\n')
@@ -83,9 +258,12 @@ export function maybeComputeGoogleDocsLintBoxes(
const editor = document.querySelector(GOOGLE_DOCS_EDITOR_SELECTOR) as HTMLElement | null;
const source = target.textContent ?? '';
const sourceMode = target.getAttribute('data-harper-gdocs-source');
+ // This is already a recognized Docs target. Missing or unknown metadata
+ // must not turn it into a legacy nearby-text correction target.
+ if (!['logical', 'rects', 'native'].includes(sourceMode ?? '')) return [];
const nativeSnapshot = target.getAttribute('data-harper-gdocs-native-snapshot');
const mapped =
- sourceMode === 'native' ||
+ ['logical', 'rects', 'native'].includes(sourceMode ?? '') ||
nativeSnapshot != null ||
target.hasAttribute('data-harper-gdocs-native-runs') ||
target.querySelector('[data-harper-gdocs-native-start]') != null;
@@ -102,7 +280,7 @@ export function maybeComputeGoogleDocsLintBoxes(
}
if (
mapped &&
- (sourceMode !== 'native' ||
+ (!['native', 'logical', 'rects'].includes(sourceMode ?? '') ||
nativeSnapshot == null ||
lint.source !== source ||
!Number.isInteger(lint.span.start) ||
@@ -114,6 +292,8 @@ export function maybeComputeGoogleDocsLintBoxes(
resolvedSpan.start < 0 ||
resolvedSpan.end <= resolvedSpan.start ||
resolvedSpan.end > nativeSnapshot.length ||
+ splitsSurrogate(nativeSnapshot, resolvedSpan.start) ||
+ splitsSurrogate(nativeSnapshot, resolvedSpan.end) ||
GOOGLE_DOCS_CONTROL_CHARACTERS.test(
nativeSnapshot.slice(resolvedSpan.start, resolvedSpan.end),
) ||