@aseity/idocs-preview 0.2.0 → 0.4.0

package/dist/view/edit-selection.js

@@ -0,0 +1,841 @@
+import { lineCaretX, locateLineSource, } from '../core/index.js';
+import { glyphOffset, glyphX } from '../core/wire.js';
+import { turnedToPage } from './selection.js';
+const wordSegmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+function lineVerticalBounds(line) {
+    const middle = line.baseline + (line.descent - line.ascent) / 2;
+    return {
+        top: middle - line.height / 2,
+        bottom: middle + line.height / 2,
+    };
+}
+function caretXForDisplayOffset(line, target) {
+    const glyphs = line.glyphs;
+    const count = glyphs.length;
+    if (count === 0)
+        return line.x;
+    for (let i = 0; i < count; i += 1) {
+        const gOff = glyphOffset(glyphs, i);
+        const gX = glyphX(glyphs, i);
+        if (gOff === target || (gOff > target && i === 0))
+            return gX;
+        if (gOff > target) {
+            const prevOff = glyphOffset(glyphs, i - 1);
+            const prevX = glyphX(glyphs, i - 1);
+            const span = Math.max(0, gOff - prevOff);
+            if (span === 0)
+                return gX;
+            const t = Math.max(0, target - prevOff) / span;
+            return prevX + (gX - prevX) * t;
+        }
+    }
+    return line.x + line.width;
+}
+function localCoords(line, x, y) {
+    if (!line.turn)
+        return [x, y];
+    const [ox, oy] = line.turn;
+    return [y - oy, ox - x];
+}
+function pageBoxForLine(line) {
+    const { top, bottom } = lineVerticalBounds(line);
+    if (!line.turn) {
+        return { left: line.x, right: line.x + line.width, top, bottom };
+    }
+    const [x1, y1] = turnedToPage(line.turn, line.x, top);
+    const [x2, y2] = turnedToPage(line.turn, line.x + line.width, bottom);
+    return {
+        left: Math.min(x1, x2),
+        right: Math.max(x1, x2),
+        top: Math.min(y1, y2),
+        bottom: Math.max(y1, y2),
+    };
+}
+function distanceToLine(placed, x, y) {
+    const dx = Math.max(placed.pageBox.left - x, 0, x - placed.pageBox.right);
+    const dy = y < placed.pageBox.top ? placed.pageBox.top - y : y >= placed.pageBox.bottom ? y - placed.pageBox.bottom + 1e-6 : 0;
+    return dy * 1e6 + dx;
+}
+function caretBoxFromX(placed, x) {
+    const { line, page, top, bottom } = placed;
+    return {
+        page,
+        x,
+        top,
+        bottom,
+        baseline: line.baseline,
+        height: line.height,
+        ...(line.turn ? { turn: line.turn } : {}),
+    };
+}
+function sameAnchor(a, b) {
+    return (a.session === b.session &&
+        a.flow === b.flow &&
+        a.offset === b.offset &&
+        a.affinity === b.affinity);
+}
+function extractLineStops(line) {
+    const segments = line.sourceSegments;
+    if (!segments || segments.length === 0)
+        return { flow: undefined, stops: [] };
+    let flow;
+    const stops = [];
+    for (const seg of segments) {
+        if (seg.source.kind === 'editable') {
+            for (const stop of seg.source.stops) {
+                if (!flow)
+                    flow = stop.anchor.flow;
+                stops.push({
+                    displayOffset: stop.displayOffset,
+                    x: caretXForDisplayOffset(line, stop.displayOffset),
+                    anchor: stop.anchor,
+                });
+            }
+        }
+        else {
+            if (seg.source.before) {
+                if (!flow)
+                    flow = seg.source.before.flow;
+                stops.push({
+                    displayOffset: seg.start,
+                    x: caretXForDisplayOffset(line, seg.start),
+                    anchor: seg.source.before,
+                });
+            }
+            if (seg.source.after) {
+                if (!flow)
+                    flow = seg.source.after.flow;
+                stops.push({
+                    displayOffset: seg.end,
+                    x: caretXForDisplayOffset(line, seg.end),
+                    anchor: seg.source.after,
+                });
+            }
+        }
+    }
+    stops.sort((a, b) => a.anchor.offset - b.anchor.offset || a.displayOffset - b.displayOffset);
+    return { flow, stops };
+}
+function chooseSegmentAtX(line, xPt) {
+    const segments = line.sourceSegments;
+    if (!segments || segments.length === 0)
+        return undefined;
+    let positive = [];
+    for (let i = 0; i < segments.length; i += 1) {
+        const seg = segments[i];
+        if (seg.start >= seg.end)
+            continue;
+        const left = caretXForDisplayOffset(line, seg.start);
+        const right = caretXForDisplayOffset(line, seg.end);
+        if (right - left > 1e-9)
+            positive.push({ idx: i, left, right });
+    }
+    if (positive.length === 0) {
+        for (let i = 0; i < segments.length; i += 1) {
+            const seg = segments[i];
+            if (seg.start < seg.end) {
+                positive.push({
+                    idx: i,
+                    left: caretXForDisplayOffset(line, seg.start),
+                    right: caretXForDisplayOffset(line, seg.end),
+                });
+            }
+        }
+    }
+    if (positive.length === 0)
+        return segments[segments.length - 1];
+    if (xPt <= positive[0].left)
+        return segments[positive[0].idx];
+    if (xPt >= positive[positive.length - 1].right) {
+        const lastSeg = segments[segments.length - 1];
+        return lastSeg.start === lastSeg.end && lastSeg.source.kind === 'editable'
+            ? lastSeg
+            : segments[positive[positive.length - 1].idx];
+    }
+    let containing;
+    for (const item of positive) {
+        if (xPt >= item.left && xPt <= item.right) {
+            if (segments[item.idx].source.kind === 'editable')
+                return segments[item.idx];
+            if (!containing)
+                containing = segments[item.idx];
+        }
+    }
+    if (containing)
+        return containing;
+    let best = segments[positive[0].idx];
+    let bestDist = Infinity;
+    for (const item of positive) {
+        const dist = xPt < item.left ? item.left - xPt : Math.max(0, xPt - item.right);
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = segments[item.idx];
+        }
+    }
+    return best;
+}
+function segmentHighlightBox(placed, seg) {
+    const { line, top, bottom } = placed;
+    let left = seg ? caretXForDisplayOffset(line, seg.start) : line.x;
+    let right = seg ? caretXForDisplayOffset(line, seg.end) : line.x + line.width;
+    if (right <= left) {
+        left = line.x;
+        right = Math.max(line.x + line.width, line.x + line.height * 0.25);
+    }
+    return {
+        left,
+        right,
+        top,
+        bottom,
+        ...(line.turn ? { turn: line.turn } : {}),
+    };
+}
+function buildFlowWords(lines) {
+    const pieces = [];
+    let flowText = '';
+    for (const placed of lines) {
+        const segments = placed.line.sourceSegments ?? [];
+        for (const seg of segments) {
+            if (seg.source.kind === 'editable') {
+                const stops = seg.source.stops;
+                for (let i = 0; i + 1 < stops.length; i += 1) {
+                    const piece = placed.line.text.slice(stops[i].displayOffset, stops[i + 1].displayOffset);
+                    if (piece.length === 0)
+                        continue;
+                    pieces.push({
+                        textStart: flowText.length,
+                        textEnd: flowText.length + piece.length,
+                        flowStart: stops[i].anchor.offset,
+                        flowEnd: stops[i + 1].anchor.offset,
+                        startAnchor: stops[i].anchor,
+                        endAnchor: stops[i + 1].anchor,
+                    });
+                    flowText += piece;
+                }
+            }
+            else if (seg.source.before && seg.source.after) {
+                const raw = placed.line.text.slice(seg.start, seg.end);
+                const piece = raw.length > 0 ? raw : '\ufffc';
+                pieces.push({
+                    textStart: flowText.length,
+                    textEnd: flowText.length + piece.length,
+                    flowStart: seg.source.before.offset,
+                    flowEnd: seg.source.after.offset,
+                    startAnchor: seg.source.before,
+                    endAnchor: seg.source.after,
+                });
+                flowText += piece;
+            }
+        }
+    }
+    if (pieces.length === 0 || flowText.length === 0)
+        return [];
+    const anchorAtTextPos = (pos) => {
+        for (const p of pieces) {
+            if (pos <= p.textStart)
+                return p.startAnchor;
+            if (pos >= p.textEnd)
+                continue;
+            const delta = pos - p.textStart;
+            if (p.flowEnd - p.flowStart === p.textEnd - p.textStart) {
+                return {
+                    ...p.startAnchor,
+                    offset: (p.flowStart + delta),
+                    affinity: 'downstream',
+                };
+            }
+            return p.startAnchor;
+        }
+        return pieces[pieces.length - 1].endAnchor;
+    };
+    const words = [];
+    for (const seg of wordSegmenter.segment(flowText)) {
+        const startPos = seg.index;
+        const endPos = seg.index + seg.segment.length;
+        words.push({
+            start: anchorAtTextPos(startPos),
+            end: anchorAtTextPos(endPos),
+            isWordLike: seg.isWordLike ?? false,
+        });
+    }
+    return words;
+}
+function stopXAtOffset(stops, targetOffset) {
+    for (const stop of stops) {
+        if (stop.anchor.offset === targetOffset)
+            return stop.x;
+    }
+    return undefined;
+}
+function displayOffsetAtFlowOffset(stops, targetOffset, clampEnd) {
+    if (stops.length === 0)
+        return undefined;
+    if (!clampEnd) {
+        for (const stop of stops) {
+            if (stop.anchor.offset >= targetOffset)
+                return stop.displayOffset;
+        }
+        return stops[stops.length - 1].displayOffset;
+    }
+    let best;
+    for (const stop of stops) {
+        if (stop.anchor.offset <= targetOffset)
+            best = stop;
+    }
+    return best?.displayOffset ?? stops[0].displayOffset;
+}
+export class EditDocumentIndex {
+    #pages;
+    #editableLines = [];
+    #flows = new Map();
+    constructor(pages) {
+        const flowBuckets = new Map();
+        this.#pages = pages.map((page, pageIndex) => {
+            const list = [];
+            for (const line of page.lines) {
+                if (!line.sourceSegments && !line.occurrence)
+                    continue;
+                const occurrenceKind = line.occurrence?.kind;
+                const isRepeated = occurrenceKind === 'repeatedHeader';
+                const isReadOnlyStory = occurrenceKind === 'readOnlyStory';
+                const hasEditableSegment = line.sourceSegments?.some((seg) => seg.source.kind === 'editable') ?? false;
+                const primary = !isRepeated && !isReadOnlyStory && hasEditableSegment;
+                const { top, bottom } = lineVerticalBounds(line);
+                const { flow, stops } = primary ? extractLineStops(line) : { flow: undefined, stops: [] };
+                const indexed = {
+                    line,
+                    page: pageIndex,
+                    flow,
+                    top,
+                    bottom,
+                    pageBox: pageBoxForLine(line),
+                    stops,
+                };
+                list.push(indexed);
+                if (primary && flow !== undefined && stops.length > 0) {
+                    this.#editableLines.push(indexed);
+                    let bucket = flowBuckets.get(flow);
+                    if (!bucket) {
+                        bucket = { path: line.path, lines: [] };
+                        flowBuckets.set(flow, bucket);
+                    }
+                    bucket.lines.push(indexed);
+                }
+            }
+            return list;
+        });
+        for (const [id, bucket] of flowBuckets) {
+            const seenOffsets = new Map();
+            const orderedStops = [];
+            for (const placed of bucket.lines) {
+                for (const stop of placed.stops) {
+                    if (!seenOffsets.has(stop.anchor.offset)) {
+                        seenOffsets.set(stop.anchor.offset, stop.anchor);
+                        orderedStops.push(stop.anchor);
+                    }
+                }
+            }
+            orderedStops.sort((a, b) => a.offset - b.offset);
+            const stopIndexByOffset = new Map();
+            orderedStops.forEach((anchor, i) => stopIndexByOffset.set(anchor.offset, i));
+            this.#flows.set(id, {
+                path: bucket.path,
+                lines: bucket.lines,
+                stops: orderedStops,
+                stopIndexByOffset,
+                words: buildFlowWords(bucket.lines),
+            });
+        }
+    }
+    flowPath(flow) {
+        return this.#flows.get(flow)?.path;
+    }
+    firstFlow() {
+        return this.#editableLines[0]?.flow;
+    }
+    flowBounds(flow) {
+        const entry = this.#flows.get(flow);
+        if (!entry || entry.stops.length === 0)
+            return undefined;
+        return {
+            start: entry.stops[0],
+            end: entry.stops[entry.stops.length - 1],
+        };
+    }
+    locatePoint(point) {
+        const lines = this.#pages[point.page];
+        if (!lines || lines.length === 0)
+            return { kind: 'empty' };
+        let best = lines[0];
+        let bestDist = Infinity;
+        for (const candidate of lines) {
+            const d = distanceToLine(candidate, point.x, point.y);
+            if (d < bestDist) {
+                best = candidate;
+                bestDist = d;
+            }
+        }
+        const occ = best.line.occurrence;
+        if (occ?.kind === 'repeatedHeader') {
+            return {
+                kind: 'readOnly',
+                target: {
+                    page: point.page,
+                    path: occ.canonicalPath || best.line.path,
+                    reason: 'repeatedHeader',
+                    box: segmentHighlightBox(best, undefined),
+                },
+            };
+        }
+        if (occ?.kind === 'readOnlyStory') {
+            return {
+                kind: 'readOnly',
+                target: {
+                    page: point.page,
+                    path: best.line.path,
+                    reason: 'unsupportedStory',
+                    box: segmentHighlightBox(best, undefined),
+                },
+            };
+        }
+        const [localX] = localCoords(best.line, point.x, point.y);
+        const hit = locateLineSource(best.line, localX);
+        if (hit.kind === 'editable') {
+            return {
+                kind: 'editable',
+                anchor: hit.anchor,
+                caret: caretBoxFromX(best, hit.x),
+                page: point.page,
+                path: best.line.path,
+            };
+        }
+        if (hit.kind === 'atomic') {
+            const seg = chooseSegmentAtX(best.line, localX);
+            const segPath = seg?.source.kind === 'atomic' && seg.source.path ? seg.source.path : best.line.path;
+            return {
+                kind: 'readOnly',
+                target: {
+                    page: point.page,
+                    path: segPath,
+                    reason: hit.reason,
+                    ...(hit.role !== undefined ? { role: hit.role } : {}),
+                    box: segmentHighlightBox(best, seg),
+                    ...(hit.before ? { before: hit.before } : {}),
+                    ...(hit.after ? { after: hit.after } : {}),
+                },
+            };
+        }
+        return { kind: 'empty' };
+    }
+    locatePointInFlow(flow, point) {
+        const entry = this.#flows.get(flow);
+        if (!entry || entry.lines.length === 0 || entry.stops.length === 0)
+            return undefined;
+        const firstLine = entry.lines[0];
+        const lastLine = entry.lines[entry.lines.length - 1];
+        if (point.page < firstLine.page)
+            return entry.stops[0];
+        if (point.page > lastLine.page)
+            return entry.stops[entry.stops.length - 1];
+        const pageLines = entry.lines.filter((line) => line.page === point.page);
+        if (pageLines.length === 0) {
+            return point.page <= firstLine.page ? entry.stops[0] : entry.stops[entry.stops.length - 1];
+        }
+        const minTop = Math.min(...pageLines.map((l) => l.pageBox.top));
+        const maxBottom = Math.max(...pageLines.map((l) => l.pageBox.bottom));
+        if (point.y < minTop) {
+            return pageLines[0].stops[0]?.anchor ?? entry.stops[0];
+        }
+        if (point.y >= maxBottom) {
+            const lastOnPage = pageLines[pageLines.length - 1];
+            return lastOnPage.stops[lastOnPage.stops.length - 1]?.anchor ?? entry.stops[entry.stops.length - 1];
+        }
+        let best = pageLines[0];
+        let bestDist = Infinity;
+        for (const candidate of pageLines) {
+            const d = distanceToLine(candidate, point.x, point.y);
+            if (d < bestDist) {
+                best = candidate;
+                bestDist = d;
+            }
+        }
+        const [localX] = localCoords(best.line, point.x, point.y);
+        return this.#closestStopOnLine(best, localX)?.anchor;
+    }
+    wordRangeInFlow(flow, point) {
+        const entry = this.#flows.get(flow);
+        if (!entry || entry.words.length === 0)
+            return undefined;
+        const anchor = this.locatePointInFlow(flow, point);
+        if (!anchor)
+            return undefined;
+        let probeOffset = anchor.offset;
+        const line = this.#findLineForAnchor(anchor);
+        if (line) {
+            const [localX] = localCoords(line.line, point.x, point.y);
+            const caret = this.caretForAnchor(anchor);
+            if (caret && localX < caret.x) {
+                const prev = this.neighborStop(anchor, 'backward');
+                if (prev)
+                    probeOffset = prev.offset;
+            }
+        }
+        if (probeOffset <= entry.words[0].start.offset) {
+            return { start: entry.words[0].start, end: entry.words[0].end };
+        }
+        for (const word of entry.words) {
+            if (probeOffset >= word.start.offset && probeOffset < word.end.offset) {
+                return { start: word.start, end: word.end };
+            }
+        }
+        const last = entry.words[entry.words.length - 1];
+        return { start: last.start, end: last.end };
+    }
+    selectionPageBounds(range) {
+        if (range.start.flow !== range.end.flow || range.start.offset >= range.end.offset)
+            return undefined;
+        const entry = this.#flows.get(range.start.flow);
+        if (!entry)
+            return undefined;
+        let targetPage;
+        let minLeft = Infinity;
+        let maxRight = -Infinity;
+        let minTop = Infinity;
+        let maxBottom = -Infinity;
+        for (const placed of entry.lines) {
+            if (placed.stops.length === 0)
+                continue;
+            if (targetPage !== undefined && placed.page !== targetPage)
+                continue;
+            const minOffset = placed.stops[0].anchor.offset;
+            const maxOffset = placed.stops[placed.stops.length - 1].anchor.offset;
+            const from = Math.max(range.start.offset, minOffset);
+            const to = Math.min(range.end.offset, maxOffset);
+            if (from >= to)
+                continue;
+            const left = stopXAtOffset(placed.stops, from);
+            const right = stopXAtOffset(placed.stops, to);
+            if (left === undefined || right === undefined)
+                continue;
+            const boxRight = right > left ? right : left + placed.line.height * 0.25;
+            targetPage = placed.page;
+            if (!placed.line.turn) {
+                minLeft = Math.min(minLeft, left);
+                maxRight = Math.max(maxRight, boxRight);
+                minTop = Math.min(minTop, placed.top);
+                maxBottom = Math.max(maxBottom, placed.bottom);
+            }
+            else {
+                const [x1, y1] = turnedToPage(placed.line.turn, left, placed.top);
+                const [x2, y2] = turnedToPage(placed.line.turn, boxRight, placed.bottom);
+                minLeft = Math.min(minLeft, x1, x2);
+                maxRight = Math.max(maxRight, x1, x2);
+                minTop = Math.min(minTop, y1, y2);
+                maxBottom = Math.max(maxBottom, y1, y2);
+            }
+        }
+        if (targetPage === undefined)
+            return undefined;
+        return {
+            page: targetPage,
+            bounds: { left: minLeft, right: maxRight, top: minTop, bottom: maxBottom },
+        };
+    }
+    caretForAnchor(anchor) {
+        const entry = this.#flows.get(anchor.flow);
+        if (!entry)
+            return undefined;
+        for (const placed of entry.lines) {
+            const x = lineCaretX(placed.line, anchor);
+            if (x !== null)
+                return caretBoxFromX(placed, x);
+        }
+        for (const placed of entry.lines) {
+            for (const seg of placed.line.sourceSegments ?? []) {
+                if (seg.source.kind !== 'atomic')
+                    continue;
+                if (seg.source.before &&
+                    seg.source.before.session === anchor.session &&
+                    seg.source.before.flow === anchor.flow &&
+                    seg.source.before.offset === anchor.offset) {
+                    return caretBoxFromX(placed, caretXForDisplayOffset(placed.line, seg.start));
+                }
+                if (seg.source.after &&
+                    seg.source.after.session === anchor.session &&
+                    seg.source.after.flow === anchor.flow &&
+                    seg.source.after.offset === anchor.offset) {
+                    return caretBoxFromX(placed, caretXForDisplayOffset(placed.line, seg.end));
+                }
+            }
+        }
+        return undefined;
+    }
+    highlightsForRange(range, page) {
+        if (range.start.flow !== range.end.flow || range.start.offset >= range.end.offset)
+            return [];
+        const entry = this.#flows.get(range.start.flow);
+        if (!entry)
+            return [];
+        const boxes = [];
+        for (const placed of entry.lines) {
+            if (placed.page !== page || placed.stops.length === 0)
+                continue;
+            const minOffset = placed.stops[0].anchor.offset;
+            const maxOffset = placed.stops[placed.stops.length - 1].anchor.offset;
+            const from = Math.max(range.start.offset, minOffset);
+            const to = Math.min(range.end.offset, maxOffset);
+            if (from >= to)
+                continue;
+            const left = stopXAtOffset(placed.stops, from);
+            const right = stopXAtOffset(placed.stops, to);
+            if (left === undefined || right === undefined)
+                continue;
+            const boxRight = right > left ? right : left + placed.line.height * 0.25;
+            boxes.push({
+                left,
+                right: boxRight,
+                top: placed.top,
+                bottom: placed.bottom,
+                ...(placed.line.turn ? { turn: placed.line.turn } : {}),
+            });
+        }
+        return boxes;
+    }
+    selectedText(range) {
+        if (range.start.flow !== range.end.flow || range.start.offset >= range.end.offset)
+            return '';
+        const entry = this.#flows.get(range.start.flow);
+        if (!entry)
+            return '';
+        let text = '';
+        for (const placed of entry.lines) {
+            for (const seg of placed.line.sourceSegments ?? []) {
+                if (seg.source.kind === 'editable') {
+                    const stops = seg.source.stops;
+                    if (stops.length === 0)
+                        continue;
+                    const segStart = stops[0].anchor.offset;
+                    const segEnd = stops[stops.length - 1].anchor.offset;
+                    if (segEnd <= range.start.offset || segStart >= range.end.offset)
+                        continue;
+                    const from = Math.max(range.start.offset, segStart);
+                    const to = Math.min(range.end.offset, segEnd);
+                    if (from >= to)
+                        continue;
+                    const dStart = displayOffsetAtFlowOffset(stops, from, false);
+                    const dEnd = displayOffsetAtFlowOffset(stops, to, true);
+                    if (dStart !== undefined && dEnd !== undefined && dEnd > dStart) {
+                        text += placed.line.text.slice(dStart, dEnd);
+                    }
+                }
+                else if (seg.source.before && seg.source.after) {
+                    if (seg.source.before.offset >= range.start.offset && seg.source.after.offset <= range.end.offset) {
+                        text += placed.line.text.slice(seg.start, seg.end);
+                    }
+                }
+            }
+        }
+        return text.replaceAll('\ufffc', '');
+    }
+    neighborStop(anchor, direction) {
+        const entry = this.#flows.get(anchor.flow);
+        if (!entry || entry.stops.length === 0)
+            return undefined;
+        const idx = entry.stopIndexByOffset.get(anchor.offset);
+        if (idx === undefined)
+            return undefined;
+        const nextIdx = direction === 'forward' ? idx + 1 : idx - 1;
+        if (nextIdx < 0 || nextIdx >= entry.stops.length)
+            return undefined;
+        return entry.stops[nextIdx];
+    }
+    moveHorizontal(anchor, direction, granularity = 'character') {
+        const entry = this.#flows.get(anchor.flow);
+        if (!entry || entry.stops.length === 0)
+            return anchor;
+        if (granularity === 'word') {
+            if (entry.words.length === 0)
+                return anchor;
+            if (direction === 'forward') {
+                for (const word of entry.words) {
+                    if (word.isWordLike && word.end.offset > anchor.offset)
+                        return word.end;
+                }
+                return entry.stops[entry.stops.length - 1];
+            }
+            for (let i = entry.words.length - 1; i >= 0; i -= 1) {
+                const word = entry.words[i];
+                if (word.isWordLike && word.start.offset < anchor.offset)
+                    return word.start;
+            }
+            return entry.stops[0];
+        }
+        const line = this.#findLineForAnchor(anchor);
+        if (direction === 'forward') {
+            const next = this.neighborStop(anchor, 'forward');
+            if (!next)
+                return anchor;
+            if (line) {
+                const lastOnLine = line.stops[line.stops.length - 1]?.anchor;
+                if (lastOnLine && lastOnLine.offset === next.offset && lastOnLine.affinity === 'upstream') {
+                    return lastOnLine;
+                }
+            }
+            return next;
+        }
+        const prev = this.neighborStop(anchor, 'backward');
+        if (!prev)
+            return anchor;
+        if (line) {
+            const firstOnLine = line.stops[0]?.anchor;
+            if (firstOnLine && firstOnLine.offset === prev.offset)
+                return firstOnLine;
+        }
+        return prev;
+    }
+    moveVertical(anchor, direction, preferredX) {
+        const caret = this.caretForAnchor(anchor);
+        const currentLine = this.#findLineForAnchor(anchor);
+        if (!caret || !currentLine) {
+            return { anchor, preferredX: preferredX ?? 0 };
+        }
+        const [caretPageX, caretPageY] = caret.turn
+            ? turnedToPage(caret.turn, caret.x, (caret.top + caret.bottom) / 2)
+            : [caret.x, (caret.top + caret.bottom) / 2];
+        const targetX = preferredX ?? caretPageX;
+        const targetLine = this.#findVerticalLine(currentLine, caretPageY, targetX, direction);
+        if (!targetLine)
+            return { anchor, preferredX: targetX };
+        const targetCenterY = (targetLine.pageBox.top + targetLine.pageBox.bottom) / 2;
+        const [localX] = localCoords(targetLine.line, targetX, targetCenterY);
+        const bestStop = this.#closestStopOnLine(targetLine, localX);
+        return {
+            anchor: bestStop ? bestStop.anchor : anchor,
+            preferredX: targetX,
+        };
+    }
+    moveLineBoundary(anchor, edge) {
+        const line = this.#findLineForAnchor(anchor);
+        if (!line || line.stops.length === 0)
+            return anchor;
+        return edge === 'start' ? line.stops[0].anchor : line.stops[line.stops.length - 1].anchor;
+    }
+    wordRangeAt(point) {
+        const hit = this.locatePoint(point);
+        if (hit.kind !== 'editable')
+            return undefined;
+        const entry = this.#flows.get(hit.anchor.flow);
+        if (!entry || entry.words.length === 0)
+            return undefined;
+        const line = this.#findLineForAnchor(hit.anchor);
+        let probeOffset = hit.anchor.offset;
+        if (line) {
+            const [localX] = localCoords(line.line, point.x, point.y);
+            if (localX < hit.caret.x) {
+                const prev = this.neighborStop(hit.anchor, 'backward');
+                if (prev)
+                    probeOffset = prev.offset;
+            }
+        }
+        for (const word of entry.words) {
+            if (probeOffset >= word.start.offset && probeOffset < word.end.offset) {
+                return { start: word.start, end: word.end };
+            }
+        }
+        const last = entry.words[entry.words.length - 1];
+        return { start: last.start, end: last.end };
+    }
+    flowRangeAt(point) {
+        const hit = this.locatePoint(point);
+        if (hit.kind !== 'editable')
+            return undefined;
+        return this.flowBounds(hit.anchor.flow);
+    }
+    #findLineForAnchor(anchor) {
+        const entry = this.#flows.get(anchor.flow);
+        if (!entry)
+            return undefined;
+        for (const placed of entry.lines) {
+            if (placed.stops.some((stop) => sameAnchor(stop.anchor, anchor))) {
+                return placed;
+            }
+        }
+        for (const placed of entry.lines) {
+            if (lineCaretX(placed.line, anchor) !== null)
+                return placed;
+        }
+        for (const placed of entry.lines) {
+            if (placed.stops.some((stop) => stop.anchor.offset === anchor.offset))
+                return placed;
+        }
+        return undefined;
+    }
+    #findVerticalLine(current, currentY, targetX, direction) {
+        const step = direction === 'down' ? 1 : -1;
+        const samePageCandidates = this.#editableLines.filter((cand) => {
+            if (cand.page !== current.page || cand === current)
+                return false;
+            const cy = (cand.pageBox.top + cand.pageBox.bottom) / 2;
+            if (direction === 'down') {
+                return cy > currentY + 1e-3 && cand.pageBox.top >= current.pageBox.top + 1e-3;
+            }
+            return cy < currentY - 1e-3 && cand.pageBox.bottom <= current.pageBox.bottom - 1e-3;
+        });
+        if (samePageCandidates.length > 0) {
+            let best = samePageCandidates[0];
+            let bestScore = Infinity;
+            for (const cand of samePageCandidates) {
+                const cy = (cand.pageBox.top + cand.pageBox.bottom) / 2;
+                const dy = Math.abs(cy - currentY);
+                const dx = Math.max(cand.pageBox.left - targetX, 0, targetX - cand.pageBox.right);
+                const score = dy * 1e6 + dx;
+                if (score < bestScore) {
+                    bestScore = score;
+                    best = cand;
+                }
+            }
+            return best;
+        }
+        for (let p = current.page + step; p >= 0 && p < this.#pages.length; p += step) {
+            const pageCandidates = this.#editableLines.filter((cand) => cand.page === p);
+            if (pageCandidates.length === 0)
+                continue;
+            const edgeY = direction === 'down'
+                ? Math.min(...pageCandidates.map((c) => (c.pageBox.top + c.pageBox.bottom) / 2))
+                : Math.max(...pageCandidates.map((c) => (c.pageBox.top + c.pageBox.bottom) / 2));
+            let best = pageCandidates[0];
+            let bestScore = Infinity;
+            for (const cand of pageCandidates) {
+                const cy = (cand.pageBox.top + cand.pageBox.bottom) / 2;
+                const dy = Math.abs(cy - edgeY);
+                const dx = Math.max(cand.pageBox.left - targetX, 0, targetX - cand.pageBox.right);
+                const score = dy * 1e6 + dx;
+                if (score < bestScore) {
+                    bestScore = score;
+                    best = cand;
+                }
+            }
+            return best;
+        }
+        return undefined;
+    }
+    #closestStopOnLine(placed, localX) {
+        const stops = placed.stops;
+        if (stops.length === 0)
+            return undefined;
+        let best = stops[0];
+        let bestDist = Math.abs(localX - best.x);
+        for (let i = 1; i < stops.length; i += 1) {
+            const stop = stops[i];
+            const dist = Math.abs(localX - stop.x);
+            if (dist < bestDist - 1e-9 || (Math.abs(dist - bestDist) <= 1e-9 && localX >= stop.x)) {
+                best = stop;
+                bestDist = dist;
+            }
+        }
+        return best;
+    }
+}
+export function orderedAnchors(a, b) {
+    return a.offset <= b.offset ? { start: a, end: b, reversed: false } : { start: b, end: a, reversed: true };
+}