@adecore/editor-core 0.42.0 → 0.44.0

package/dist/statement-move.js

@@ -0,0 +1,361 @@
+import { isBraced } from './lexical.js';
+import { indentText, isBlank, whitespaceOf } from './line-text.js';
+import { mapOffset } from './offsets.js';
+import { DECLARATION, declarationBody, METHOD, NOT_METHODS, indentWidth, statementAt, visualWidth } from './statements.js';
+const INDENTED = /^(python|py|yaml|yml)$/i;
+const CONTROL = /^(?:if|else|elseif|for|foreach|while|do|try|catch|finally|switch|with)\b/;
+/* How a language moves a statement: by brackets, by indentation, or as plain lines when it has neither. */
+export function statementMoveMode(language) {
+    return isBraced(language) ? 'braced' : INDENTED.test(language) ? 'indented' : null;
+}
+function rangeOf(first, last) {
+    return Array.from({ length: Math.max(0, last - first + 1) }, (_, i) => first + i);
+}
+function slots(lines, shift = 0) {
+    return lines.map((line) => ({ line, shift }));
+}
+function trimmed(source, line) {
+    return source.line(line).text.trim();
+}
+function startsWithBrace(source, line) {
+    return trimmed(source, line).startsWith('}');
+}
+function opensBlock(source, line) {
+    return trimmed(source, line).endsWith('{');
+}
+/* The header of a block that a statement may leave: a control statement or a bare block, never a function, a class or a literal. */
+function isControlHeader(source, line) {
+    const text = trimmed(source, line).replace(/^\}\s*/, '');
+    return text === '{' || CONTROL.test(text);
+}
+class Planner {
+    source;
+    options;
+    unitWidth;
+    constructor(source, options) {
+        this.source = source;
+        this.options = options;
+        this.unitWidth = visualWidth(options.unit, options.tabSize);
+    }
+    widen(range) {
+        const span = this.options.lineSpan;
+        return span === undefined ? range : { first: Math.min(range.first, span(range.first).first), last: Math.max(range.last, span(range.last).last) };
+    }
+    statementAt(line) {
+        const { first, code, last } = statementAt(this.source, line, this.options.language, this.options.structure);
+        return { ...this.widen({ first, last }), code };
+    }
+    indentOf(line) {
+        return indentWidth(this.source.line(line).text, this.options.tabSize);
+    }
+    /* The lines of the statements a selection touches. */
+    unitOf(selection) {
+        const from = Math.min(selection.anchor, selection.head);
+        const to = Math.max(selection.anchor, selection.head);
+        const first = this.source.lineAt(from);
+        let lastLine = this.source.lineAt(to);
+        if (lastLine > first && this.source.line(lastLine).start === to) {
+            lastLine--;
+        }
+        if (statementMoveMode(this.options.language) === 'indented') {
+            return this.widen({ first, last: this.deeperEnd(lastLine) });
+        }
+        const start = this.statementAt(first);
+        const end = this.statementAt(lastLine);
+        return { first: Math.min(start.first, end.first), last: Math.max(start.last, end.last) };
+    }
+    /* The last line of the block of deeper lines under a line, for a language that nests by indentation. */
+    deeperEnd(line) {
+        const indent = this.indentOf(line);
+        let last = line;
+        for (let next = line + 1; next < this.source.lineCount; next++) {
+            if (isBlank(this.source.line(next).text)) {
+                continue;
+            }
+            if (this.indentOf(next) <= indent) {
+                break;
+            }
+            last = next;
+        }
+        return last;
+    }
+    declarationLevel(unit) {
+        const { source } = this;
+        const info = this.statementAt(unit.first);
+        const header = trimmed(source, info.code);
+        const body = declarationBody(source, source.line(info.code).start);
+        const method = body === 'other' ? METHOD.exec(header)?.[1] : undefined;
+        return (body !== null ||
+            DECLARATION.test(header) ||
+            (method !== undefined && !NOT_METHODS.has(method)) ||
+            this.options.structure.some((range) => range.startLine === info.code && /^(?:function|method|class)-body$/.test(range.role ?? '')));
+    }
+    plan(unit, direction) {
+        if (statementMoveMode(this.options.language) === 'indented') {
+            return direction === 1 ? this.indentedDown(unit) : this.indentedUp(unit);
+        }
+        if (this.declarationLevel(unit)) {
+            return direction === 1 ? this.declarationDown(unit) : this.declarationUp(unit);
+        }
+        return direction === 1 ? this.statementDown(unit) : this.statementUp(unit);
+    }
+    declarationDown(unit) {
+        const { source } = this;
+        let next = unit.last + 1;
+        while (next < source.lineCount && isBlank(source.line(next).text)) {
+            next++;
+        }
+        if (next >= source.lineCount || startsWithBrace(source, next)) {
+            return null;
+        }
+        const neighbor = this.statementAt(next);
+        if (neighbor.first <= unit.last) {
+            return null;
+        }
+        return {
+            region: { first: unit.first, last: neighbor.last },
+            order: slots([...rangeOf(neighbor.first, neighbor.last), ...rangeOf(unit.last + 1, neighbor.first - 1), ...rangeOf(unit.first, unit.last)])
+        };
+    }
+    declarationUp(unit) {
+        const { source } = this;
+        let previous = unit.first - 1;
+        while (previous >= 0 && isBlank(source.line(previous).text)) {
+            previous--;
+        }
+        if (previous < 0) {
+            return null;
+        }
+        const neighbor = this.statementAt(previous);
+        if (neighbor.last >= unit.first) {
+            return null;
+        }
+        return {
+            region: { first: neighbor.first, last: unit.last },
+            order: slots([...rangeOf(unit.first, unit.last), ...rangeOf(neighbor.last + 1, unit.first - 1), ...rangeOf(neighbor.first, neighbor.last)])
+        };
+    }
+    statementDown(unit) {
+        const { source } = this;
+        const next = unit.last + 1;
+        if (next >= source.lineCount) {
+            return null;
+        }
+        const own = rangeOf(unit.first, unit.last);
+        const swapWith = (last) => ({ region: { first: unit.first, last }, order: slots([...rangeOf(next, last), ...own]) });
+        if (isBlank(source.line(next).text)) {
+            return swapWith(next);
+        }
+        if (startsWithBrace(source, next)) {
+            // `} else {` ends one block and opens the next, so the statement only steps across it.
+            if (opensBlock(source, next)) {
+                return swapWith(next);
+            }
+            return this.leaveDown(unit, next);
+        }
+        if (/^[)\]]/.test(trimmed(source, next))) {
+            return null;
+        }
+        const neighbor = this.statementAt(next);
+        if (neighbor.first !== next) {
+            return null;
+        }
+        const header = this.headerEnd(neighbor);
+        if (header !== null) {
+            const shift = this.indentOf(neighbor.code) + this.unitWidth - this.indentOf(unit.first);
+            return { region: { first: unit.first, last: header }, order: [...slots(rangeOf(next, header)), ...slots(own, shift)] };
+        }
+        return swapWith(neighbor.last);
+    }
+    /* The line a block statement opens on, when it has a block to enter. */
+    headerEnd(neighbor) {
+        const { source } = this;
+        if (neighbor.last <= neighbor.code) {
+            return null;
+        }
+        if (opensBlock(source, neighbor.code)) {
+            return neighbor.code;
+        }
+        return neighbor.code + 1 <= neighbor.last && trimmed(source, neighbor.code + 1) === '{' ? neighbor.code + 1 : null;
+    }
+    leaveDown(unit, closer) {
+        const { source } = this;
+        const info = source.line(closer);
+        const opener = source.context(info.start + info.text.length - info.text.trimStart().length).bracket;
+        if (opener === undefined) {
+            return null;
+        }
+        const owner = this.statementAt(source.lineAt(opener.at));
+        if (!isControlHeader(source, owner.code)) {
+            return null;
+        }
+        const shift = this.indentOf(owner.code) - this.indentOf(unit.first);
+        return {
+            region: { first: unit.first, last: owner.last },
+            order: [...slots(rangeOf(closer, owner.last)), ...slots(rangeOf(unit.first, unit.last), shift)]
+        };
+    }
+    statementUp(unit) {
+        const { source } = this;
+        const previous = unit.first - 1;
+        if (previous < 0) {
+            return null;
+        }
+        const own = rangeOf(unit.first, unit.last);
+        const swapWith = (first) => ({ region: { first, last: unit.last }, order: slots([...own, ...rangeOf(first, previous)]) });
+        if (isBlank(source.line(previous).text)) {
+            return swapWith(previous);
+        }
+        if (opensBlock(source, previous)) {
+            if (startsWithBrace(source, previous)) {
+                return swapWith(previous);
+            }
+            const owner = this.statementAt(previous);
+            if (!isControlHeader(source, owner.code)) {
+                return null;
+            }
+            const shift = this.indentOf(owner.code) - this.indentOf(unit.first);
+            return {
+                region: { first: owner.first, last: unit.last },
+                order: [...slots(own, shift), ...slots(rangeOf(owner.first, previous))]
+            };
+        }
+        const neighbor = this.statementAt(previous);
+        if (neighbor.last >= unit.first) {
+            return null;
+        }
+        if (neighbor.first < previous && startsWithBrace(source, previous)) {
+            const shift = this.indentOf(previous) + this.unitWidth - this.indentOf(unit.first);
+            return { region: { first: previous, last: unit.last }, order: [...slots(own, shift), ...slots([previous])] };
+        }
+        return swapWith(neighbor.first);
+    }
+    indentedDown(unit) {
+        const { source } = this;
+        const next = unit.last + 1;
+        if (next >= source.lineCount) {
+            return null;
+        }
+        const own = rangeOf(unit.first, unit.last);
+        if (isBlank(source.line(next).text)) {
+            return { region: { first: unit.first, last: next }, order: slots([next, ...own]) };
+        }
+        if (this.indentOf(next) < this.indentOf(unit.first)) {
+            return null;
+        }
+        const last = this.deeperEnd(next);
+        return { region: { first: unit.first, last }, order: slots([...rangeOf(next, last), ...own]) };
+    }
+    indentedUp(unit) {
+        const { source } = this;
+        const previous = unit.first - 1;
+        if (previous < 0) {
+            return null;
+        }
+        const own = rangeOf(unit.first, unit.last);
+        if (isBlank(source.line(previous).text)) {
+            return { region: { first: previous, last: unit.last }, order: slots([...own, previous]) };
+        }
+        const indent = this.indentOf(unit.first);
+        if (this.indentOf(previous) < indent) {
+            return null;
+        }
+        let first = previous;
+        while (first > 0 && (this.indentOf(first) > indent || isBlank(source.line(first).text))) {
+            first--;
+        }
+        if (this.indentOf(first) !== indent) {
+            return null;
+        }
+        return { region: { first, last: unit.last }, order: slots([...own, ...rangeOf(first, previous)]) };
+    }
+}
+/* The text of a line with its indentation grown by `shift` columns; a blank line stays as it is. */
+function shifted(text, shift, options) {
+    if (shift === 0 || isBlank(text)) {
+        return text;
+    }
+    const indent = whitespaceOf(text);
+    const width = Math.max(0, visualWidth(indent, options.tabSize) + shift);
+    return indentText(width, { tabSize: options.tabSize, insertSpaces: !options.unit.includes('\t') }) + text.slice(indent.length);
+}
+/*
+ * Moves the statement at each caret past the one before it (-1) or after it (1), into a block the way a person
+ * would carry it, or out of one. Null when no caret can move. A language with neither brackets nor indentation
+ * to go by is the model's to move by lines.
+ */
+export function planMoveStatement(source, selections, direction, options) {
+    const planner = new Planner(source, options);
+    const units = [];
+    for (const unit of selections.map((selection) => planner.unitOf(selection)).sort((left, right) => left.first - right.first)) {
+        const previous = units.at(-1);
+        if (previous !== undefined && unit.first <= previous.last + 1) {
+            previous.last = Math.max(previous.last, unit.last);
+        }
+        else {
+            units.push({ ...unit });
+        }
+    }
+    const moves = [];
+    for (const unit of units) {
+        const move = planner.plan(unit, direction);
+        const previous = moves.at(-1);
+        // A group whose lines another group is also moving stays where it is.
+        if (move !== null && (previous === undefined || move.region.first > previous.region.last)) {
+            moves.push(move);
+        }
+    }
+    return moves.length === 0 ? null : apply(source, selections, moves, options);
+}
+function apply(source, selections, moves, options) {
+    const edits = [];
+    const moved = [];
+    const lines = [];
+    const ordered = moves.toSorted((left, right) => left.region.first - right.region.first);
+    for (const { region, order } of ordered) {
+        const parts = [];
+        const placed = [];
+        let at = source.line(region.first).start;
+        for (const [index, slot] of order.entries()) {
+            const info = source.line(slot.line);
+            const target = source.line(region.first + index);
+            const text = shifted(info.text, slot.shift, options);
+            const ending = source.slice(target.end, target.next);
+            parts.push(text, ending);
+            placed.push({ line: slot.line, offset: at, length: text.length + ending.length, text: text.length, indent: whitespaceOf(text).length });
+            at += text.length + ending.length;
+            if (slot.line !== region.first + index) {
+                lines.push({ from: slot.line, to: region.first + index });
+            }
+        }
+        edits.push({ from: source.line(region.first).start, to: source.line(region.last).next, text: parts.join('') });
+        moved.push(placed);
+    }
+    const mapPoint = (offset, keepWithLineAbove) => {
+        const line = source.lineAt(keepWithLineAbove ? offset - 1 : offset);
+        const index = ordered.findIndex(({ region }) => line >= region.first && line <= region.last);
+        if (index < 0) {
+            return mapOffset(offset, edits);
+        }
+        const place = moved[index].find((slot) => slot.line === line);
+        const info = source.line(line);
+        if (keepWithLineAbove) {
+            return place.offset + place.length;
+        }
+        const column = offset - info.start;
+        const before = whitespaceOf(info.text).length;
+        return place.offset + (column >= before ? Math.min(column - before + place.indent, place.text) : Math.min(column, place.indent));
+    };
+    return {
+        edits,
+        selections: selections.map((selection) => {
+            const from = Math.min(selection.anchor, selection.head);
+            const to = Math.max(selection.anchor, selection.head);
+            const endsAtLineStart = to > from && source.line(source.lineAt(to)).start === to;
+            const start = mapPoint(from, false);
+            const end = mapPoint(to, endsAtLineStart);
+            return selection.anchor <= selection.head ? { anchor: start, head: end } : { anchor: end, head: start };
+        }),
+        moves: lines
+    };
+}

package/dist/statements.d.ts

@@ -0,0 +1,23 @@
+import type { EditSource } from './edit-source.ts';
+import type { FoldingRange } from './structure.ts';
+export declare function indentWidth(text: string, tabSize: number): number;
+export declare function visualWidth(text: string, tabSize: number): number;
+export declare function enclosingBraces(source: EditSource, offset: number): number[];
+export declare function enclosingBrace(source: EditSource, offset: number): number | null;
+export interface IndentGuide {
+    startLine: number;
+    endLine: number;
+}
+export declare function indentGuideAt(source: EditSource, line: number, column: number, tabSize: number): IndentGuide | null;
+export declare function statementStart(source: EditSource, line: number, language: string): number;
+export declare const DECLARATION: RegExp;
+export declare const METHOD: RegExp;
+export declare const NOT_METHODS: Set<string>;
+export declare const BODIES: Set<string>;
+export declare function declarationBody(source: EditSource, offset: number): 'interface' | 'other' | null;
+export interface StatementRange {
+    first: number;
+    code: number;
+    last: number;
+}
+export declare function statementAt(source: EditSource, line: number, language: string, structure?: readonly FoldingRange[]): StatementRange;

package/dist/statements.js

@@ -0,0 +1,221 @@
+import { lineContinues } from './enter.js';
+import { isBlank, whitespaceOf } from './line-text.js';
+/* The indentation of a line text in columns, tabs taken to their stops. */
+export function indentWidth(text, tabSize) {
+    return visualWidth(whitespaceOf(text), tabSize);
+}
+/* The width in columns of a text that starts a line, tabs taken to their stops. */
+export function visualWidth(text, tabSize) {
+    let width = 0;
+    for (const character of text) {
+        width += character === '\t' ? tabSize - (width % tabSize) : 1;
+    }
+    return width;
+}
+/* The `{` brackets the offset is inside, innermost first. None in a string, a comment or markup, and an `${` of a template is no block. */
+export function enclosingBraces(source, offset) {
+    const context = source.context(offset);
+    if (context.mode !== 'code') {
+        return [];
+    }
+    const braces = [];
+    for (let bracket = context.bracket; bracket !== undefined; bracket = bracket.previous) {
+        if (bracket.close === '}' && bracket.template !== true) {
+            braces.push(bracket.at);
+        }
+    }
+    return braces;
+}
+/* The innermost `{` around the offset, or null. */
+export function enclosingBrace(source, offset) {
+    return enclosingBraces(source, offset)[0] ?? null;
+}
+function nextNonBlank(source, line) {
+    let next = line + 1;
+    while (next < source.lineCount && isBlank(source.line(next).text)) {
+        next++;
+    }
+    return next;
+}
+/*
+ * The guide an editor draws at `column` (in columns, tabs expanded) that holds `line`: a line at that indent
+ * whose next non-blank line is deeper starts it, and the first later non-blank line at or above that indent ends it.
+ */
+export function indentGuideAt(source, line, column, tabSize) {
+    if (column <= 0 || line < 0 || line >= source.lineCount) {
+        return null;
+    }
+    for (let start = line; start >= 0; start--) {
+        const text = source.line(start).text;
+        if (isBlank(text)) {
+            continue;
+        }
+        const indent = indentWidth(text, tabSize);
+        if (indent > column) {
+            continue;
+        }
+        const following = nextNonBlank(source, start);
+        if (indent < column || following >= source.lineCount || indentWidth(source.line(following).text, tabSize) <= column) {
+            return null;
+        }
+        let end = following;
+        while (end < source.lineCount && (isBlank(source.line(end).text) || indentWidth(source.line(end).text, tabSize) > column)) {
+            end++;
+        }
+        return end > line ? { startLine: start, endLine: end } : null;
+    }
+    return null;
+}
+const CONTINUATION_START = /^(?:\{|\.|\?\.|&&|\|\||\?\?|\+(?!\+)|-(?!-)|\?|:|else\b|catch\b|finally\b)/;
+/*
+ * The first line of the statement a line belongs to: a line that opens with a closer belongs to the statement of its
+ * opener, and a line the one above leaves open, or that goes on with a member access, an operator or `else`, to the one above.
+ */
+export function statementStart(source, line, language) {
+    let first = line;
+    // Each step goes up at least one line, so the walk ends.
+    while (first > 0) {
+        const info = source.line(first);
+        const lead = info.text.length - info.text.trimStart().length;
+        const opener = /^[)\]}]/.test(info.text.slice(lead)) ? source.context(info.start + lead).bracket : undefined;
+        const openerLine = opener === undefined ? first : source.lineAt(opener.at);
+        if (openerLine < first) {
+            first = openerLine;
+            continue;
+        }
+        const above = first - 1;
+        if (isBlank(source.line(above).text) || !(CONTINUATION_START.test(info.text.trimStart()) || lineContinues(source, language, above))) {
+            break;
+        }
+        first = above;
+    }
+    return first;
+}
+const MODIFIERS = '(?:export\\s+|default\\s+|declare\\s+|abstract\\s+|async\\s+|pub(?:\\([^)]*\\))?\\s+|public\\s+|private\\s+|protected\\s+|static\\s+|final\\s+|readonly\\s+|override\\s+|unsafe\\s+|extern\\s+)*';
+// The outline of the editor reads headers the same way; a statement is not a declaration when it ends in a value, so `type` and `namespace` are left out.
+export const DECLARATION = new RegExp(`^${MODIFIERS}(function\\*?|class|interface|enum|trait|impl|struct|fn|func|object|record)\\b`);
+export const METHOD = /^(?:(?:public|private|protected|static|async|get|set|override|readonly|abstract)\s+)*\*?\s*([A-Za-z_$#][\w$]*)\s*[(<]/;
+export const NOT_METHODS = new Set([
+    'if',
+    'for',
+    'while',
+    'switch',
+    'catch',
+    'function',
+    'return',
+    'else',
+    'with',
+    'do',
+    'try',
+    'new',
+    'await',
+    'typeof',
+    'super',
+    'finally'
+]);
+export const BODIES = new Set(['class', 'interface', 'enum', 'trait', 'impl', 'struct', 'object', 'record']);
+/* What kind of body the offset is in: that of an interface, of another type or namespace, or none of them. */
+export function declarationBody(source, offset) {
+    const brace = enclosingBrace(source, offset);
+    if (brace === null) {
+        return null;
+    }
+    const braceLine = source.lineAt(brace);
+    const own = source.line(braceLine).text.slice(0, brace - source.line(braceLine).start);
+    // A brace on a line of its own belongs to the header above it.
+    const header = own.trim() === '' && braceLine > 0 ? source.line(braceLine - 1).text : own;
+    if (/\binterface\b/.test(header)) {
+        return 'interface';
+    }
+    return /\b(?:class|enum|trait|impl|struct|object|record|namespace)\b/.test(header) ? 'other' : null;
+}
+/* The doc comment a line is part of, as the lines it spans. */
+function docCommentAt(source, line) {
+    let first = line;
+    while (first >= 0 && !source.line(first).text.trim().startsWith('/**') && source.line(first).text.trim().startsWith('*')) {
+        first--;
+    }
+    if (first < 0 || !source.line(first).text.trim().startsWith('/**')) {
+        return null;
+    }
+    let last = first;
+    while (last < source.lineCount - 1 && !source.line(last).text.includes('*/')) {
+        last++;
+    }
+    return last >= line ? { first, last } : null;
+}
+function isAttribute(text) {
+    return /^\s*(?:@|#\[)/.test(text);
+}
+const NO_STRUCTURE = [];
+/* The offset of the bracket that is still open at the start of a line and is no block of statements. */
+function enclosingOpener(source, line) {
+    const open = source.context(source.line(line).start).bracket;
+    return open !== undefined && open.template !== true && !(open.close === '}' && open.block === true) ? open.at : null;
+}
+function chainLength(source, offset) {
+    let length = 0;
+    for (let bracket = source.context(offset).bracket; bracket !== undefined; bracket = bracket.previous) {
+        length++;
+    }
+    return length;
+}
+/* The last line of the statement that starts on `from`: where the brackets it opened are closed again and nothing goes on. */
+function statementLast(source, from, language) {
+    const depth = chainLength(source, source.line(from).start);
+    const isDo = /^\s*do\b/.test(source.line(from).text);
+    for (let line = from; line < source.lineCount; line++) {
+        const info = source.line(line);
+        if (chainLength(source, info.end) > depth || lineContinues(source, language, line)) {
+            continue;
+        }
+        const next = line + 1 < source.lineCount ? source.line(line + 1).text.trimStart() : '';
+        if (next !== '' && (CONTINUATION_START.test(next) || (isDo && /^while\b/.test(next))) && !isBlank(info.text)) {
+            continue;
+        }
+        return line;
+    }
+    return source.lineCount - 1;
+}
+/*
+ * The lines of the statement a line belongs to. A doc comment and the attributes right above it are part of it, a line
+ * in them stands for the statement below, and a range a server or a bracket pair folds from its first line sets its end.
+ */
+export function statementAt(source, line, language, structure = NO_STRUCTURE) {
+    let code = line;
+    const doc = docCommentAt(source, code);
+    if (doc !== null) {
+        code = doc.last + 1;
+    }
+    while (code < source.lineCount - 1 && isAttribute(source.line(code).text)) {
+        code++;
+    }
+    if (code >= source.lineCount || isBlank(source.line(code).text)) {
+        return { first: line, code: line, last: line };
+    }
+    // A line inside brackets a line above opened belongs to the statement of that line.
+    for (let open = enclosingOpener(source, code); open !== null; open = enclosingOpener(source, code)) {
+        code = statementStart(source, source.lineAt(open), language);
+    }
+    code = statementStart(source, code, language);
+    let first = code;
+    for (let above = first - 1; above >= 0; above = first - 1) {
+        const comment = source.line(above).text.trim().endsWith('*/') ? docCommentAt(source, above) : null;
+        if (comment !== null) {
+            first = comment.first;
+        }
+        else if (isAttribute(source.line(above).text)) {
+            first = above;
+        }
+        else {
+            break;
+        }
+    }
+    let last = statementLast(source, code, language);
+    for (const range of structure) {
+        if (range.startLine === code && range.endLine > last) {
+            last = range.endLine;
+        }
+    }
+    return { first, code, last };
+}

package/dist/surround-shape.d.ts

@@ -0,0 +1,9 @@
+import type { EditSource } from './edit-source.ts';
+export interface SurroundShape {
+    readonly from: number;
+    readonly to: number;
+    readonly statements: boolean;
+    readonly expression: boolean;
+}
+export declare function atStatementStart(source: EditSource, offset: number, language: string): boolean;
+export declare function surroundShape(source: EditSource, from: number, to: number, language: string): SurroundShape | null;