@adecore/editor 0.22.1 → 0.23.0

package/dist/paint.js

@@ -1,5 +1,7 @@
-import { colorValue } from './attribution.js';
-import { scanLine } from './layout.js';
+import { offsetOfStop, rowOfStop, stopAtOffset, stopCount, xOfStop } from './geometry-stops.js';
+import { colorValue, tintValue } from './attribution.js';
+import { scanLine, subRowBand } from './layout.js';
+import { BIDI_CONTROLS, BIDI_PATTERN, visibleBidi } from './bidi.js';
 const ITALIC = 1;
 const BOLD = 2;
 const UNDERLINE = 4;
@@ -64,36 +66,61 @@ function fillRun(run, geometry, from, to, tokens, whitespace, tokensFrom = geome
         }
     }
 }
-/* One line of text as absolutely placed runs and inlays. `firstRowOnly` leaves out what a wrapped line carries onto later visual lines. */
-export function lineElement(document, geometry, tokens, lineHeight, firstRowOnly, whitespace = false) {
+export function lineElement(document, geometry, tokens, lineHeight, band, whitespace = false) {
     const element = document.createElement('div');
     element.className = 'se-line';
     element.style.width = `${geometry.width}px`;
-    for (const run of geometry.runs) {
-        if (firstRowOnly && run.subRow > 0) {
-            continue;
+    let first = 0;
+    let last = geometry.runs.length;
+    while (first < last) {
+        const middle = (first + last) >>> 1;
+        if (geometry.runs[middle].subRow < band.first) {
+            first = middle + 1;
+        }
+        else {
+            last = middle;
+        }
+    }
+    for (let index = first; index < geometry.runs.length; index++) {
+        const run = geometry.runs[index];
+        if (run.subRow > band.last) {
+            break;
         }
         const span = document.createElement('span');
         span.className = 'se-run';
         span.style.left = `${run.x}px`;
         span.style.top = `${run.subRow * lineHeight}px`;
-        fillRun(span, geometry, run.from, run.to, tokens, whitespace);
+        fillRun(span, geometry, geometry.start + run.from, geometry.start + run.to, tokens, whitespace);
         element.append(span);
     }
     if (whitespace) {
-        appendTabSigns(element, geometry, lineHeight, firstRowOnly);
+        appendTabSigns(element, geometry, lineHeight, band);
     }
+    appendBidiSigns(element, geometry, lineHeight, band);
     for (const box of geometry.inlays) {
-        if (firstRowOnly && box.subRow > 0) {
+        if (box.subRow < band.first || box.subRow > band.last) {
             continue;
         }
         const span = document.createElement('span');
         span.className = box.inlay.ghost ? 'se-ghost' : box.inlay.composition ? 'se-composition' : 'se-inlay';
         span.dataset.inlayId = box.inlay.id;
-        span.textContent = box.inlay.text;
-        span.style.left = `${box.x}px`;
+        const { parts } = box.inlay;
+        if (parts === undefined) {
+            span.textContent = visibleBidi(box.inlay.text);
+        }
+        else {
+            parts.forEach((part, index) => {
+                const element = document.createElement('span');
+                element.className = 'se-inlay-part';
+                element.dataset.part = String(index);
+                element.textContent = visibleBidi(part);
+                span.append(element);
+            });
+        }
+        const gapLeft = box.inlay.gapLeft ?? 0;
+        span.style.left = `${box.x + gapLeft}px`;
         span.style.top = `${box.subRow * lineHeight}px`;
-        span.style.width = `${box.width}px`;
+        span.style.width = `${box.width - gapLeft - (box.inlay.gapRight ?? 0)}px`;
         element.append(span);
     }
     return element;
@@ -125,7 +152,10 @@ export class RowPainter {
         }
         let measured = false;
         for (const row of rows) {
-            if (row.kind === 'text') {
+            if (row.kind === 'text' && row.replacement !== undefined) {
+                measured = this.paintReplacement(row, row.replacement, paint) || measured;
+            }
+            else if (row.kind === 'text') {
                 this.paintText(row, paint);
             }
             else {
@@ -137,6 +167,10 @@ export class RowPainter {
     paintText(row, paint) {
         const geometry = this.layout.geometry(row);
         const tokens = paint.tokensOf(row.line);
+        // Block boundaries keep a scroll within the band from rebuilding its text DOM.
+        const band = geometry.subRows <= 64
+            ? { first: 0, last: geometry.subRows - 1 }
+            : subRowBand(row.top, geometry.subRows, this.layout.metrics.lineHeight, paint.window, 64);
         const folded = row.lastLine > row.line;
         const lastLine = folded && row.tail !== null ? this.layout.document.getLine(row.lastLine) : null;
         const tail = lastLine === null ? '' : lastLine.text.slice(row.tail - lastLine.start);
@@ -149,8 +183,10 @@ export class RowPainter {
             entry.whitespace !== paint.whitespace ||
             entry.folded !== folded ||
             entry.tail !== tail ||
-            entry.tailTokens !== tailTokens) {
-            const element = this.buildText(row, geometry, tokens, paint, tail, tailTokens);
+            entry.tailTokens !== tailTokens ||
+            entry.band?.first !== band.first ||
+            entry.band?.last !== band.last) {
+            const element = this.buildText(row, geometry, tokens, paint, tail, tailTokens, band);
             if (entry) {
                 entry.element.replaceWith(element);
             }
@@ -166,7 +202,8 @@ export class RowPainter {
                 folded,
                 tail,
                 tailTokens,
-                revision: 0
+                revision: 0,
+                band
             };
             this.rows.set(row.key, entry);
         }
@@ -174,11 +211,11 @@ export class RowPainter {
         entry.element.style.height = `${row.height}px`;
         entry.element.dataset.line = String(row.line);
     }
-    buildText(row, geometry, tokens, paint, tail, tailTokens) {
+    buildText(row, geometry, tokens, paint, tail, tailTokens, band) {
         const document = this.code.ownerDocument;
         const lineHeight = this.layout.metrics.lineHeight;
-        const element = lineElement(document, geometry, tokens, lineHeight, false, paint.whitespace);
-        if (row.lastLine > row.line) {
+        const element = lineElement(document, geometry, tokens, lineHeight, band, paint.whitespace);
+        if (row.lastLine > row.line && band.last === geometry.subRows - 1) {
             const chip = document.createElement('button');
             chip.type = 'button';
             chip.className = 'se-fold-chip';
@@ -208,9 +245,42 @@ export class RowPainter {
             span.className = 'se-run';
             span.style.left = `${left + run.x}px`;
             span.style.top = `${(header.subRows - 1) * this.layout.metrics.lineHeight}px`;
-            fillRun(span, geometry, run.from, run.to, tokens, false, lineStart);
+            fillRun(span, geometry, geometry.start + run.from, geometry.start + run.to, tokens, false, lineStart);
             element.append(span);
         }
+        appendBidiSigns(element, geometry, this.layout.metrics.lineHeight, { first: 0, last: 0 }, left, (header.subRows - 1) * this.layout.metrics.lineHeight);
+    }
+    /* The lines the host draws itself: an element of its own, indented as the first line is and as tall as its content. */
+    paintReplacement(row, replacement, paint) {
+        const revision = replacement.revision ?? 0;
+        let entry = this.rows.get(row.key);
+        if (!entry) {
+            const element = this.code.ownerDocument.createElement('div');
+            element.className = 'se-block se-replacement';
+            element.dataset.rowKey = row.key;
+            element.dataset.replacementId = replacement.id;
+            element.setAttribute('role', 'group');
+            if (replacement.label !== undefined) {
+                element.setAttribute('aria-label', replacement.label);
+            }
+            replacement.render(element);
+            this.code.append(element);
+            entry = { element, text: '', tokens: null, layoutVersion: 0, whitespace: false, folded: false, tail: '', tailTokens: null, revision };
+            this.rows.set(row.key, entry);
+        }
+        else if (entry.revision !== revision) {
+            entry.element.replaceChildren();
+            replacement.render(entry.element);
+            entry.revision = revision;
+        }
+        const indent = this.layout.indentX(row.line);
+        entry.element.style.top = `${row.top}px`;
+        entry.element.style.left = `${indent}px`;
+        entry.element.style.width = `${Math.max(80, paint.viewportWidth - indent)}px`;
+        entry.element.style.height = '';
+        this.observer?.observe(entry.element);
+        const height = entry.element.getBoundingClientRect?.().height ?? 0;
+        return height > 0 && this.layout.setMeasuredHeight(row.key, height);
     }
     paintBlock(row, paint) {
         const { widget } = row;
@@ -223,7 +293,7 @@ export class RowPainter {
             element.dataset.widgetId = widget.id;
             this.fillBlock(element, widget);
             this.code.append(element);
-            if (!widget.lens) {
+            if (!widget.lens && !widget.fixed) {
                 this.observer?.observe(element);
             }
             entry = { element, text: '', tokens: null, layoutVersion: 0, whitespace: false, folded: false, tail: '', tailTokens: null, revision };
@@ -247,6 +317,13 @@ export class RowPainter {
         else {
             entry.element.style.width = `${Math.max(80, paint.viewportWidth)}px`;
         }
+        if (widget.fixed) {
+            this.observer?.unobserve(entry.element);
+            entry.element.style.height = `${row.height}px`;
+            return false;
+        }
+        entry.element.style.height = '';
+        this.observer?.observe(entry.element);
         const height = entry.element.getBoundingClientRect?.().height ?? 0;
         return height > 0 && this.layout.setMeasuredHeight(row.key, height);
     }
@@ -286,13 +363,33 @@ export function paintGutter(container, layout, rows, paint) {
         item.className = paint.activeLines.has(row.line) ? 'se-line-number se-active-number' : 'se-line-number';
         item.style.top = `${row.top}px`;
         item.style.height = `${layout.metrics.lineHeight}px`;
-        const fill = paint.highlights.get(row.line)?.fill;
+        const highlight = paint.highlights.get(row.line);
+        const fill = highlight?.fill;
         if (fill !== undefined) {
             item.style.background = colorValue(fill);
         }
+        if (highlight?.bar !== undefined) {
+            item.classList.add('se-line-marked');
+            item.style.height = `${row.height}px`;
+            item.style.setProperty('--se-line', `${layout.metrics.lineHeight}px`);
+            item.style.setProperty('--se-mark', colorValue(highlight.color));
+            if (fill === undefined) {
+                item.style.setProperty('--se-tint', tintValue(highlight.color));
+            }
+        }
         const number = document.createElement('span');
-        number.textContent = String(row.line + 1);
+        number.textContent = paint.lineNumber(row.line);
+        const label = paint.lineLabel(row.line);
+        if (label !== null) {
+            number.setAttribute('aria-hidden', 'true');
+        }
         item.append(number);
+        if (label !== null) {
+            const hidden = document.createElement('span');
+            hidden.className = 'se-sr-only';
+            hidden.textContent = label;
+            item.append(hidden);
+        }
         if (paint.action?.line === row.line) {
             const button = gutterButton(document, 'se-gutter-action', paint.action.label);
             button.dataset.gutterAction = String(row.line);
@@ -302,6 +399,12 @@ export function paintGutter(container, layout, rows, paint) {
         if (marker !== undefined) {
             const button = gutterButton(document, 'se-gutter-marker', marker.label);
             button.dataset.gutterMarker = marker.id;
+            if (marker.icon !== undefined) {
+                button.dataset.icon = marker.icon;
+            }
+            if (marker.pressed !== undefined) {
+                button.setAttribute('aria-pressed', String(marker.pressed));
+            }
             item.append(button);
         }
         const sign = paint.highlights.get(row.line)?.sign;
@@ -309,9 +412,18 @@ export function paintGutter(container, layout, rows, paint) {
             const mark = document.createElement('span');
             mark.className = 'se-line-sign';
             mark.textContent = sign;
+            if (label !== null) {
+                mark.setAttribute('aria-hidden', 'true');
+            }
             mark.style.color = colorValue(paint.highlights.get(row.line).color);
             item.append(mark);
         }
+        if (highlight?.bar !== undefined) {
+            const mark = document.createElement('span');
+            mark.className = `se-line-bar se-line-bar-${highlight.bar}`;
+            mark.setAttribute('aria-hidden', 'true');
+            item.append(mark);
+        }
         const bar = paint.attribution.get(row.line);
         if (bar) {
             const mark = document.createElement('span');
@@ -323,7 +435,7 @@ export function paintGutter(container, layout, rows, paint) {
         }
         const change = paint.changes.get(row.line);
         // The bar of an agent stands where the mark of a change would, and a removal is a triangle between lines that the bar never hides.
-        if (change && (!bar || change === 'deleted')) {
+        if (change && (!bar || change === 'deleted') && highlight?.bar === undefined) {
             const mark = document.createElement('span');
             mark.className = `se-change se-change-${change}`;
             if (change !== 'deleted') {
@@ -333,7 +445,8 @@ export function paintGutter(container, layout, rows, paint) {
         }
         const collapsed = paint.foldable.get(row.line);
         if (collapsed !== undefined) {
-            const button = gutterButton(document, collapsed ? 'se-fold-toggle se-folded' : 'se-fold-toggle', collapsed ? 'Expand' : 'Collapse');
+            const button = gutterButton(document, collapsed ? 'se-fold-toggle se-folded' : 'se-fold-toggle', paint.foldName(row.line, collapsed));
+            button.setAttribute('aria-expanded', String(!collapsed));
             button.dataset.foldLine = String(row.line);
             item.append(button);
         }
@@ -415,10 +528,10 @@ export function paintSticky(container, entries, lineHeight) {
         row.dataset.depth = String(depth);
         const number = document.createElement('span');
         number.className = 'se-sticky-number';
-        number.textContent = String(entry.line + 1);
+        number.textContent = entry.label;
         const code = document.createElement('div');
         code.className = 'se-sticky-code';
-        code.append(lineElement(document, entry.geometry, entry.tokens, lineHeight, true));
+        code.append(lineElement(document, entry.geometry, entry.tokens, lineHeight, { first: 0, last: 0 }));
         row.append(number, code);
         return row;
     }));
@@ -448,20 +561,53 @@ export function arrowSign(document, width, lineHeight, className) {
     return svg;
 }
 /* An arrow over each tab of a line. */
-function appendTabSigns(element, geometry, lineHeight, firstRowOnly) {
+function appendTabSigns(element, geometry, lineHeight, band) {
+    if (geometry.uniform !== undefined) {
+        return;
+    }
     const document = element.ownerDocument;
-    for (let stop = 0; stop < geometry.offsets.length - 1; stop++) {
-        if (geometry.text[geometry.offsets[stop]] !== '\t' || (firstRowOnly && geometry.rowOf[stop] > 0)) {
+    const end = geometry.rowStarts[band.last + 1] ?? stopCount(geometry) - 1;
+    for (let stop = geometry.rowStarts[band.first]; stop < end; stop++) {
+        if (geometry.text[offsetOfStop(geometry, stop)] !== '\t') {
             continue;
         }
-        const left = geometry.before[stop];
-        const right = geometry.rowOf[stop + 1] === geometry.rowOf[stop] ? geometry.before[stop + 1] : geometry.rowEnds[geometry.rowOf[stop]];
+        const left = xOfStop(geometry, stop);
+        const right = rowOfStop(geometry, stop + 1) === rowOfStop(geometry, stop) ? xOfStop(geometry, stop + 1) : geometry.rowEnds[rowOfStop(geometry, stop)];
         if (right - left < 3) {
             continue;
         }
         const sign = arrowSign(document, right - left - 2, lineHeight, 'se-tab-sign');
         sign.style.left = `${left + 1}px`;
-        sign.style.top = `${geometry.rowOf[stop] * lineHeight}px`;
+        sign.style.top = `${rowOfStop(geometry, stop) * lineHeight}px`;
+        element.append(sign);
+    }
+}
+/*
+ * A boxed label over each bidirectional control character, which no run carries, so the control never reaches the text nodes
+ * where it would reorder the line. `top` and `originX` place a line that is drawn as part of another one.
+ */
+function appendBidiSigns(element, geometry, lineHeight, band, originX = 0, top) {
+    if (geometry.uniform !== undefined) {
+        return;
+    }
+    const document = element.ownerDocument;
+    const from = offsetOfStop(geometry, geometry.rowStarts[band.first]);
+    const to = geometry.rowStarts[band.last + 1] === undefined ? geometry.text.length : offsetOfStop(geometry, geometry.rowStarts[band.last + 1]);
+    const pattern = new RegExp(BIDI_PATTERN.source, 'g');
+    pattern.lastIndex = from;
+    for (let match = pattern.exec(geometry.text); match !== null && match.index < to; match = pattern.exec(geometry.text)) {
+        const stop = stopAtOffset(geometry, match.index);
+        const row = rowOfStop(geometry, stop);
+        const control = BIDI_CONTROLS[match[0]];
+        const left = xOfStop(geometry, stop);
+        const right = rowOfStop(geometry, stop + 1) === row ? xOfStop(geometry, stop + 1) : geometry.rowEnds[row];
+        const sign = document.createElement('span');
+        sign.className = 'se-bidi';
+        sign.textContent = control.label;
+        sign.style.left = `${originX + left}px`;
+        sign.style.top = `${top ?? row * lineHeight}px`;
+        sign.style.width = `${right - left}px`;
+        sign.style.height = `${lineHeight}px`;
         element.append(sign);
     }
 }

package/dist/search-client.d.ts

@@ -0,0 +1,27 @@
+import type { FindMatch } from '@adecore/editor-core';
+import type { EditorFindQuery } from './types.ts';
+import { type EditorSearchRange, type EditorSearchNextOptions, type EditorSearchReplacementOptions, type EditorSearchReplacements, type EditorSearchOptions, type EditorSearchResult, type EditorSearchSnapshot } from './search-protocol.ts';
+export type EditorSearchErrorKind = 'timeout' | 'superseded' | 'unavailable' | 'syntax' | 'range' | 'snapshot' | 'error' | 'disposed';
+export declare class EditorSearchError extends Error {
+    readonly kind: EditorSearchErrorKind;
+    constructor(kind: EditorSearchErrorKind, message: string);
+}
+export interface EditorSearchClientOptions {
+    readonly workerFactory: () => Pick<Worker, 'addEventListener' | 'removeEventListener' | 'postMessage' | 'terminate'>;
+    readonly deadline?: number;
+    readonly schedule?: (callback: () => void, delay: number) => () => void;
+}
+export interface EditorSearchClient {
+    search(snapshot: EditorSearchSnapshot, query: EditorFindQuery, options?: EditorSearchOptions): Promise<EditorSearchResult>;
+    match(snapshot: EditorSearchSnapshot, query: EditorFindQuery, range: {
+        readonly from: number;
+        readonly to: number;
+        readonly deadline?: number;
+    }): Promise<FindMatch | null>;
+    next(snapshot: EditorSearchSnapshot, query: EditorFindQuery, offset: number, options?: EditorSearchNextOptions): Promise<EditorSearchRange | null>;
+    replacements(snapshot: EditorSearchSnapshot, query: EditorFindQuery, replacement: string, options?: EditorSearchReplacementOptions): Promise<EditorSearchReplacements>;
+    cancel(): void;
+    release(): void;
+    dispose(): void;
+}
+export declare function createSearchClient(options: EditorSearchClientOptions): EditorSearchClient;

package/dist/search-client.js

@@ -0,0 +1,210 @@
+import { createWorkerRequestClient, WorkerRequestError } from './worker-client.js';
+import { SEARCH_LIMIT, MAX_REPLACEMENT_PAGE, MAX_REPLACEMENT_CHARACTERS } from './search-protocol.js';
+export class EditorSearchError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.name = 'EditorSearchError';
+        this.kind = kind;
+    }
+}
+function validateSearch(snapshot, query, options) {
+    const from = options.from ?? 0;
+    const to = options.to ?? snapshot.text.length;
+    const maximum = options.maxResults ?? SEARCH_LIMIT;
+    if (!Number.isSafeInteger(snapshot.revision) ||
+        snapshot.revision < 0 ||
+        !Number.isInteger(from) ||
+        !Number.isInteger(to) ||
+        from < 0 ||
+        to < from ||
+        to > snapshot.text.length) {
+        throw new EditorSearchError('range', 'Search bounds and revision must identify the current document.');
+    }
+    if (!Number.isInteger(maximum) || maximum < 0 || maximum > SEARCH_LIMIT) {
+        throw new EditorSearchError('range', `Search results must be limited to ${SEARCH_LIMIT} matches or fewer.`);
+    }
+    if (options.deadline !== undefined && (!Number.isFinite(options.deadline) || options.deadline <= 0 || options.deadline > 2147483647)) {
+        throw new EditorSearchError('range', 'A request deadline must fit a positive browser timer.');
+    }
+    if (query.regex) {
+        try {
+            // Compilation reports syntax errors without executing the expression on the page.
+            new RegExp(query.text, `gmu${query.caseSensitive ? '' : 'i'}`);
+        }
+        catch (error) {
+            throw new EditorSearchError('syntax', error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+function splitsSurrogate(text, offset) {
+    const previous = text.charCodeAt(offset - 1), current = text.charCodeAt(offset);
+    return previous >= 0xd800 && previous <= 0xdbff && current >= 0xdc00 && current <= 0xdfff;
+}
+export function createSearchClient(options) {
+    let revision;
+    const transport = createWorkerRequestClient({
+        ...options,
+        accepts: (reply, input) => reply.revision === input.revision,
+        failure: (reply) => reply.type === 'error'
+            ? { error: new EditorSearchError(reply.kind, reply.message), restart: reply.kind !== 'syntax' && reply.kind !== 'range' }
+            : undefined,
+        prepare: (input) => {
+            const { text, ...rest } = input;
+            const message = { ...rest, ...(revision !== input.revision ? { text } : {}) };
+            revision = input.revision;
+            return message;
+        },
+        stopped: () => {
+            revision = undefined;
+        }
+    });
+    const run = (snapshot, query, bounds, input, read, validate) => {
+        return transport
+            .request(input, bounds.deadline, () => {
+            validateSearch(snapshot, query, bounds);
+            validate?.();
+        })
+            .then((reply) => {
+            if (reply.type === 'error') {
+                throw new EditorSearchError(reply.kind, reply.message);
+            }
+            return read(reply);
+        })
+            .catch((error) => {
+            throw error instanceof WorkerRequestError
+                ? new EditorSearchError(error.kind, error.message)
+                : error instanceof EditorSearchError
+                    ? error
+                    : new EditorSearchError('error', error instanceof Error ? error.message : String(error));
+        });
+    };
+    return {
+        search(snapshot, query, bounds = {}) {
+            return run(snapshot, query, bounds, (id) => ({
+                type: 'search',
+                id,
+                revision: snapshot.revision,
+                text: snapshot.text,
+                query: { ...query },
+                ...bounds,
+                maxResults: bounds.maxResults ?? SEARCH_LIMIT
+            }), (reply) => {
+                if (reply.type !== 'matches') {
+                    throw new EditorSearchError('error', 'The worker returned an unexpected search response.');
+                }
+                return { revision: reply.revision, ranges: reply.ranges, limited: reply.limited };
+            });
+        },
+        match(snapshot, query, range) {
+            const from = range.from, to = range.to;
+            const text = snapshot.text;
+            return run(snapshot, query, { from, to, maxResults: 1, deadline: range.deadline }, (id) => ({ type: 'match', id, revision: snapshot.revision, text, query: { ...query }, from, to }), (reply) => {
+                if (reply.type !== 'match') {
+                    throw new EditorSearchError('error', 'The worker returned an unexpected match response.');
+                }
+                if (reply.match === null) {
+                    return null;
+                }
+                if (reply.match.from !== from || reply.match.to !== to) {
+                    throw new EditorSearchError('error', 'The worker returned a different match range.');
+                }
+                return { ...reply.match, text: text.slice(from, to), revision: reply.revision };
+            });
+        },
+        next(snapshot, query, offset, bounds = {}) {
+            return run(snapshot, query, { from: bounds.from, to: bounds.to, maxResults: 1, deadline: bounds.deadline }, (id) => ({ type: 'next', id, revision: snapshot.revision, text: snapshot.text, query: { ...query }, offset, ...bounds }), (reply) => {
+                if (reply.type !== 'next') {
+                    throw new EditorSearchError('error', 'The worker returned an unexpected cursor response.');
+                }
+                const range = reply.range;
+                if (range !== null &&
+                    (!Number.isInteger(range.from) ||
+                        !Number.isInteger(range.to) ||
+                        range.from < (bounds.from ?? 0) ||
+                        range.to < range.from ||
+                        range.to > (bounds.to ?? snapshot.text.length) ||
+                        splitsSurrogate(snapshot.text, range.from) ||
+                        splitsSurrogate(snapshot.text, range.to))) {
+                    throw new EditorSearchError('error', 'The worker returned invalid cursor bounds.');
+                }
+                return range;
+            });
+        },
+        replacements(snapshot, query, replacement, options = {}) {
+            const { from, to, preserveCase } = options;
+            const maxEdits = options.maxEdits ?? 1000;
+            const maxCharacters = options.maxCharacters ?? MAX_REPLACEMENT_CHARACTERS;
+            return run(snapshot, query, { from, to, maxResults: 1, deadline: options.deadline }, (id) => ({
+                type: 'replacements',
+                id,
+                revision: snapshot.revision,
+                text: snapshot.text,
+                query: { ...query },
+                from,
+                to,
+                preserveCase,
+                replacement,
+                maxEdits,
+                maxCharacters
+            }), (reply) => {
+                if (reply.type !== 'replacements') {
+                    throw new EditorSearchError('error', 'The worker returned an unexpected replacement response.');
+                }
+                if (reply.ranges.length % 3 !== 0 || reply.ranges.length / 3 > maxEdits || reply.text.length > maxCharacters) {
+                    throw new EditorSearchError('error', 'The worker returned an invalid replacement page.');
+                }
+                let characters = 0;
+                let previous = from ?? 0;
+                let previousEmpty = false;
+                for (let index = 0; index < reply.ranges.length; index += 3) {
+                    const start = reply.ranges[index], end = reply.ranges[index + 1];
+                    if (start < previous ||
+                        (previousEmpty && start === previous) ||
+                        end < start ||
+                        end > (to ?? snapshot.text.length) ||
+                        splitsSurrogate(snapshot.text, start) ||
+                        splitsSurrogate(snapshot.text, end)) {
+                        throw new EditorSearchError('error', 'The worker returned invalid replacement bounds.');
+                    }
+                    previous = end;
+                    previousEmpty = start === end;
+                    characters += reply.ranges[index + 2];
+                }
+                if (characters !== reply.text.length) {
+                    throw new EditorSearchError('error', 'The worker returned inconsistent replacement lengths.');
+                }
+                if (reply.next !== null) {
+                    const index = reply.ranges.length - 3;
+                    if (index < 0) {
+                        throw new EditorSearchError('error', 'The worker returned an empty replacement continuation.');
+                    }
+                    const start = reply.ranges[index], end = reply.ranges[index + 1];
+                    const resume = end + (start === end ? ((snapshot.text.codePointAt(end) ?? 0) > 0xffff ? 2 : 1) : 0);
+                    if (reply.next !== resume || reply.next > (to ?? snapshot.text.length)) {
+                        throw new EditorSearchError('error', 'The worker returned an invalid replacement continuation.');
+                    }
+                }
+                return { revision: reply.revision, ranges: reply.ranges, text: reply.text, next: reply.next };
+            }, () => {
+                if (!Number.isInteger(maxEdits) ||
+                    maxEdits < 1 ||
+                    maxEdits > MAX_REPLACEMENT_PAGE ||
+                    !Number.isInteger(maxCharacters) ||
+                    maxCharacters < 0 ||
+                    maxCharacters > MAX_REPLACEMENT_CHARACTERS) {
+                    throw new EditorSearchError('range', 'Replacement pages need a positive edit limit and a bounded character limit.');
+                }
+            });
+        },
+        cancel() {
+            transport.cancel();
+        },
+        release() {
+            transport.release();
+        },
+        dispose() {
+            transport.dispose();
+        }
+    };
+}