@adecore/editor-core 0.0.1 → 0.17.0-beta.2

package/dist/edit-source.d.ts

@@ -0,0 +1,19 @@
+import type { VueRegion } from './languages.ts';
+import type { DocumentLine } from './rope.ts';
+import type { TypingContext } from './typing-context.ts';
+import type { Selection, TextEdit } from './types.ts';
+export interface EditSource {
+    slice(from: number, to: number): string;
+    charAt(offset: number): string;
+    lineAt(offset: number): number;
+    lineCount: number;
+    line(index: number): DocumentLine;
+    newline(index: number): string;
+    context(offset: number): TypingContext;
+    region(line: number): VueRegion | null;
+    unmatchedBrace(offset: number): boolean;
+}
+export interface EditPlan {
+    edits: TextEdit[];
+    selections: Selection[];
+}

package/dist/edit-source.js

@@ -0,0 +1 @@
+export {};

package/dist/enter.d.ts

@@ -0,0 +1,17 @@
+import type { EditSource } from './edit-source.ts';
+import type { TypingContext } from './typing-context.ts';
+export interface EnterOptions {
+    language: string;
+    unit: string;
+    tabSize: number;
+    smart: boolean;
+    reach: boolean;
+}
+export interface EnterPlan {
+    from: number;
+    to: number;
+    text: string;
+    caret: number;
+}
+export declare function continues(text: string, context: TypingContext, language: string): boolean;
+export declare function planEnter(source: EditSource, from: number, to: number, options: EnterOptions): EnterPlan;

package/dist/enter.js

@@ -0,0 +1,387 @@
+import { commentSyntax } from './languages.js';
+import { hasHashComments, isBraced, isPhp } from './lexical.js';
+import { hasJsx, isJsxAttributeValue } from './markup-regions.js';
+import { indentationColumn } from './structure.js';
+const closers = { '(': ')', '[': ']', '{': '}' };
+const concatenation = new Map();
+for (const id of 'typescript javascript typescriptreact javascriptreact tsx jsx ts js java csharp cs kotlin scala dart swift go groovy'.split(' ')) {
+    concatenation.set(id, '+');
+}
+concatenation.set('php', '.');
+const markupLanguages = /^(html|xml|svg|vue|svelte|astro|mdx|jsx|tsx|javascriptreact|typescriptreact)$/i;
+const voidElements = /^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/i;
+const trailingOperator = /(?:=>|&&|\|\||\?\?|[=*%?|&]|(?<!\+)\+|(?<!-)-)$/;
+const lookBack = 50;
+/* The longest text a JSX attribute is looked for in on an Enter. */
+const jsxScanLimit = 2_000_000;
+/* How far past the caret a comment is searched for its end. */
+const commentReach = 20_000;
+function whitespaceOf(text) {
+    return /^[\t ]*/.exec(text)[0];
+}
+function isBlank(text) {
+    return /^[\t ]*$/.test(text);
+}
+function escapeForPattern(text) {
+    return text.replace(/[.*+?^${}()|[\]\\/-]/g, '\\$&');
+}
+/*
+ * Whether the code before `end` leaves its statement open: after the parenthesis of a braceless
+ * `if` or `for`, after `else`, `=>` or a binary operator. Languages with braces only.
+ */
+export function continues(text, context, language) {
+    if (!isBraced(language) || context.mode !== 'code') {
+        return false;
+    }
+    if (context.word === 'control-close' || context.word === 'else' || context.word === 'do') {
+        return true;
+    }
+    if (isPhp(language) && /(?<!\.)\.$/.test(text)) {
+        return true;
+    }
+    return trailingOperator.test(text);
+}
+class Enter {
+    source;
+    options;
+    constructor(source, options) {
+        this.source = source;
+        this.options = options;
+    }
+    plan(from, to) {
+        const { source, options } = this;
+        const index = source.lineAt(from);
+        const line = source.line(index);
+        const before = source.slice(line.start, from);
+        const leading = whitespaceOf(before);
+        const newline = source.newline(index);
+        if (!options.smart) {
+            return { from, to, text: newline + leading, caret: newline.length + leading.length };
+        }
+        const context = source.context(from);
+        const selection = from !== to;
+        const planned = context.mode === 'block-comment'
+            ? this.inBlockComment(from, to, context, index)
+            : context.mode === 'line-comment' && !selection
+                ? this.inLineComment(from, context, index)
+                : context.mode === 'quote' && !selection
+                    ? this.inString(from, context, index)
+                    : null;
+        return planned ?? this.inCode(from, to, context, index);
+    }
+    /* The indentation a new statement after this line gets, which is not the line's own when the line is a continuation. */
+    baseIndent(index, depth = 0) {
+        const line = this.source.line(index);
+        const own = whitespaceOf(line.text);
+        const previous = this.previousCodeLine(index);
+        if (previous === null || depth > lookBack || !this.lineContinues(previous)) {
+            return own;
+        }
+        return this.baseIndent(previous, depth + 1);
+    }
+    previousCodeLine(index) {
+        for (let candidate = index - 1; candidate >= 0 && candidate >= index - lookBack; candidate--) {
+            if (!isBlank(this.source.line(candidate).text)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    lineContinues(index) {
+        const line = this.source.line(index);
+        const text = line.text.trimEnd();
+        return text.length > 0 && continues(text, this.source.context(line.start + text.length), this.options.language);
+    }
+    inCode(from, to, lineContext, index) {
+        const { source, options } = this;
+        const line = source.line(index);
+        const before = source.slice(line.start, from);
+        const leading = whitespaceOf(before);
+        const newline = source.newline(index);
+        const { unit, language } = options;
+        // A comment that trails the code is not part of what decides the indentation.
+        const commentAt = lineContext.mode === 'line-comment' ? lineContext.commentStart : undefined;
+        const trailing = commentAt !== undefined && commentAt >= line.start && !isBlank(source.slice(line.start, commentAt));
+        const trimmed = trailing ? source.slice(line.start, commentAt).trimEnd() : before.trimEnd();
+        const context = trailing ? source.context(line.start + trimmed.length) : lineContext;
+        const last = trimmed.at(-1) ?? '';
+        const rest = source.slice(to, line.end);
+        const afterWhitespace = to + whitespaceOf(rest).length;
+        const next = source.charAt(afterWhitespace);
+        const base = context.mode === 'code' ? this.baseIndent(index) : leading;
+        const start = leading.length < before.length ? base : leading;
+        const plain = (indent) => ({ from, to: afterWhitespace, text: newline + indent, caret: newline.length + indent.length });
+        if (context.mode !== 'code') {
+            return plain(leading);
+        }
+        const opener = closers[last] !== undefined && context.bracket?.close === closers[last] && context.bracket.at === line.start + trimmed.length - 1;
+        if (opener) {
+            const inner = start + unit;
+            if (next === closers[last]) {
+                return { from, to: afterWhitespace, text: newline + inner + newline + start, caret: newline.length + inner.length };
+            }
+            const closing = last === '{' && source.unmatchedBrace(context.bracket.at) ? this.closeBrace(from, afterWhitespace, line, rest, newline, start, inner) : null;
+            return closing ?? plain(inner);
+        }
+        const tag = this.openTag(trimmed, index);
+        if (tag) {
+            const inner = start + unit;
+            if (new RegExp(`^</${escapeForPattern(tag)}\\s*>`, 'i').test(source.slice(afterWhitespace, line.end))) {
+                return { from, to: afterWhitespace, text: newline + inner + newline + start, caret: newline.length + inner.length };
+            }
+            return plain(inner);
+        }
+        if (this.opensIndentedBlock(trimmed, context)) {
+            return plain(this.blockIndent(line.text, start) + unit);
+        }
+        if (continues(trimmed, context, language)) {
+            const continued = this.previousCodeLine(index) !== null && this.lineContinues(this.previousCodeLine(index));
+            return plain(continued ? leading : start + unit);
+        }
+        return plain(start);
+    }
+    /* The `}` of a `{` that nothing closes goes under the line it opens, or after what follows the caret when that is a statement. */
+    closeBrace(from, afterWhitespace, line, rest, newline, base, inner) {
+        const tail = rest.trimStart();
+        if (tail === '' || /^[)\];,%<?]/.test(tail)) {
+            const text = newline + inner + newline + base + '}';
+            return { from, to: afterWhitespace, text, caret: newline.length + inner.length };
+        }
+        if (!this.options.reach) {
+            return null;
+        }
+        const text = newline + inner + tail.trimEnd() + newline + base + '}';
+        return { from, to: line.end, text, caret: newline.length + inner.length };
+    }
+    /* The name of the tag the text ends in, when it is an open tag with children to come. */
+    openTag(trimmed, index) {
+        const { language } = this.options;
+        if (!markupLanguages.test(language)) {
+            return null;
+        }
+        if (/^vue$/i.test(language) && this.source.region(index) === 'script') {
+            return null;
+        }
+        const match = /(?:^|[^\w$)\]])<([A-Za-z][\w:.-]*)(?:\s(?:[^<>]|=>)*)?>$/.exec(trimmed);
+        if (!match || trimmed.endsWith('/>') || (voidElements.test(match[1]) && !/^xml$/i.test(language))) {
+            return null;
+        }
+        return match[1];
+    }
+    /* Python's `def f():`, a YAML `key:` and a `case x:`. */
+    opensIndentedBlock(trimmed, context) {
+        const { language } = this.options;
+        if (/^(python|py)$/i.test(language)) {
+            return trimmed.endsWith(':') && context.bracket === undefined;
+        }
+        if (/^(yaml|yml)$/i.test(language)) {
+            return /(?::|[|>][+-]?)$/.test(trimmed) && !trimmed.trimStart().startsWith('#');
+        }
+        if (isBraced(language)) {
+            return (context.bracket === undefined || context.bracket.close === '}') && /^(?:case\b[^]*|default)\s*:$/.test(trimmed.trimStart());
+        }
+        return false;
+    }
+    /* A YAML list item's children line up with its key, not with its dash. */
+    blockIndent(text, start) {
+        if (!/^(yaml|yml)$/i.test(this.options.language)) {
+            return start;
+        }
+        const dashes = /^[\t ]*(?:- +)+/.exec(text)?.[0];
+        return dashes ? start + ' '.repeat(dashes.length - whitespaceOf(text).length) : start;
+    }
+    inLineComment(from, context, index) {
+        const { source, options } = this;
+        const line = source.line(index);
+        const commentStart = context.commentStart;
+        const syntax = commentSyntax(options.language, source.region(index));
+        // A hash comment of a language that has both, as in PHP, continues with its own marker.
+        const token = commentStart !== undefined && hasHashComments(options.language) && source.charAt(commentStart) === '#' ? '#' : syntax.line;
+        if (commentStart === undefined || commentStart < line.start || token === null) {
+            return null;
+        }
+        const marker = new RegExp(`^${escapeForPattern(token)}${token === '//' ? '[/!]?' : token === '#' ? '#*' : ''}`).exec(source.slice(commentStart, line.end))?.[0];
+        if (marker === undefined || from < commentStart + marker.length) {
+            return null;
+        }
+        const rest = source.slice(from, line.end);
+        const textStart = from + whitespaceOf(rest).length;
+        if (textStart >= line.end) {
+            return null;
+        }
+        const newline = source.newline(index);
+        const leading = whitespaceOf(source.slice(line.start, from));
+        if (source.slice(textStart, textStart + token.length) === token) {
+            return { from, to: textStart, text: newline + leading, caret: newline.length + leading.length };
+        }
+        const code = source.slice(line.start, commentStart);
+        const onlyComment = isBlank(code);
+        let spacing = ' ';
+        if (onlyComment) {
+            const gap = whitespaceOf(source.slice(commentStart + marker.length, line.end));
+            spacing = gap === '' ? ' ' : gap;
+        }
+        else if (source.charAt(from) === ' ') {
+            spacing = '';
+        }
+        const text = newline + leading + marker + spacing;
+        return { from, to: textStart, text, caret: text.length };
+    }
+    inString(from, context, index) {
+        const { source, options } = this;
+        const operator = concatenation.get(options.language.toLowerCase());
+        const quote = context.quote;
+        if (operator === undefined || (quote !== '"' && quote !== "'")) {
+            return null;
+        }
+        const line = source.line(index);
+        const opener = this.stringStart(line, from, quote);
+        if (opener !== null && (this.isModulePath(line, opener, index) || this.isMarkupAttribute(opener))) {
+            return null;
+        }
+        let at = from;
+        if (context.escaped) {
+            at += /^(?:u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|.)/.exec(source.slice(from, line.end))?.[0].length ?? 0;
+        }
+        if (!this.closesOnLine(at, quote, line)) {
+            return null;
+        }
+        const newline = source.newline(index);
+        const previous = this.previousCodeLine(index);
+        const leading = whitespaceOf(line.text);
+        const continued = previous !== null && this.lineContinues(previous);
+        const indent = continued ? leading : leading + options.unit;
+        const text = `${quote} ${operator}${newline}${indent}${quote}`;
+        const rest = source.slice(at, line.end);
+        return { from: at, to: at + whitespaceOf(rest).length, text, caret: text.length };
+    }
+    /* Where the string the caret is in opened, when it opened on this line. */
+    stringStart(line, from, quote) {
+        let open = null;
+        for (let at = line.start; at < from; at++) {
+            const char = this.source.charAt(at);
+            if (open === null) {
+                if (char === '"' || char === "'" || char === '`') {
+                    open = { at, quote: char };
+                }
+            }
+            else if (char === '\\') {
+                at++;
+            }
+            else if (char === open.quote) {
+                open = null;
+            }
+        }
+        return open?.quote === quote ? open.at : null;
+    }
+    /* A path an import, a `require` or an `export ... from` names, where a break and a concatenation would name another file. */
+    isModulePath(line, opener, index) {
+        const before = this.source.slice(line.start, opener).trimEnd();
+        if (/(?:^|[^\w$.])(?:import|from|require|require_once|include|include_once)\s*\(?$/.test(before)) {
+            return true;
+        }
+        return /^go$/i.test(this.options.language) && before === '' && this.inGoImportBlock(index);
+    }
+    inGoImportBlock(index) {
+        for (let candidate = index - 1; candidate >= 0 && candidate >= index - lookBack; candidate--) {
+            const text = this.source.line(candidate).text.trim();
+            if (/^import\s*\($/.test(text)) {
+                return true;
+            }
+            if (text.startsWith(')')) {
+                return false;
+            }
+        }
+        return false;
+    }
+    /* The value of a JSX attribute, which has to stay one string. */
+    isMarkupAttribute(opener) {
+        if (!hasJsx(this.options.language)) {
+            return false;
+        }
+        const last = this.source.line(this.source.lineCount - 1).end;
+        return last <= jsxScanLimit && isJsxAttributeValue(this.source.slice(0, last), opener);
+    }
+    closesOnLine(from, quote, line) {
+        const text = this.source.slice(from, line.end);
+        for (let at = 0; at < text.length; at++) {
+            if (text[at] === '\\') {
+                at++;
+            }
+            else if (text[at] === quote) {
+                return true;
+            }
+        }
+        return false;
+    }
+    inBlockComment(from, to, context, index) {
+        const { source, options } = this;
+        const syntax = commentSyntax(options.language, source.region(index));
+        const open = context.commentStart;
+        if (syntax.block?.open !== '/*' || open === undefined || from < open + 2) {
+            return null;
+        }
+        const startIndex = source.lineAt(open);
+        const startLine = source.line(startIndex);
+        const line = source.line(index);
+        const code = source.slice(startLine.start, open);
+        const lead = this.commentLead(code);
+        const newline = source.newline(index);
+        const closeAt = this.closingOf(open, from);
+        const isDoc = source.slice(open, open + 3) === '/**' && source.slice(open, open + 4) !== '/**/';
+        const caretText = line.text.trimStart();
+        const onStar = index > startIndex && caretText.startsWith('*') && !caretText.startsWith('*/');
+        const onOpener = index === startIndex;
+        const rest = source.slice(to, line.end);
+        const textStart = to + whitespaceOf(rest).length;
+        if (closeAt === null) {
+            const star = onOpener || onStar ? this.starPrefix(line, lead, onStar, isDoc) : whitespaceOf(line.text);
+            const tail = source.slice(textStart, line.end).trimEnd();
+            const closer = `${newline}${lead} */`;
+            if (options.reach) {
+                const text = newline + star + tail + closer;
+                return { from, to: line.end, text, caret: newline.length + star.length };
+            }
+            return { from, to: textStart, text: newline + star, caret: newline.length + star.length };
+        }
+        if (isDoc && onOpener && source.lineAt(closeAt) === index && isBlank(source.slice(to, closeAt)) && isBlank(source.slice(closeAt + 2, line.end))) {
+            // Nothing left to say after the caret: the closer gets a line of its own, under the opener's star.
+            const star = this.starPrefix(line, lead, false, isDoc);
+            return { from, to: line.end, text: `${newline}${star}${newline}${lead} */`, caret: newline.length + star.length };
+        }
+        const second = source.line(startIndex + 1).text.trimStart();
+        const continuesStars = onOpener ? isDoc : second.startsWith('*') && !second.startsWith('*/');
+        if (!continuesStars) {
+            return null;
+        }
+        const star = this.starPrefix(line, lead, onStar, isDoc);
+        return { from, to: textStart, text: newline + star, caret: newline.length + star.length };
+    }
+    /* The whitespace that puts a star under the first star of an opener that stands after `code`. */
+    commentLead(code) {
+        const indent = whitespaceOf(code);
+        const gap = indentationColumn(code, this.options.tabSize) - indentationColumn(indent, this.options.tabSize);
+        return indent + ' '.repeat(gap);
+    }
+    /* A line of a comment that starts with `*` keeps its own alignment and the indentation inside a doc comment; any other line gets the opener's. */
+    starPrefix(line, lead, onStar, isDoc) {
+        if (!onStar) {
+            return `${lead} * `;
+        }
+        const inside = /^\*([\t ]*)/.exec(line.text.trimStart())?.[1] ?? '';
+        return `${whitespaceOf(line.text)}*${isDoc && inside !== '' ? inside : ' '}`;
+    }
+    /* Where the comment opened at `open` ends after `from`, or null when it runs on or swallows another comment. */
+    closingOf(open, from) {
+        const text = this.source.slice(from, from + commentReach);
+        const close = text.indexOf('*/');
+        if (close < 0) {
+            return null;
+        }
+        return this.source.slice(open + 2, from + close).includes('/*') ? null : from + close;
+    }
+}
+/* Where one Enter puts its break and caret, as a replacement of text around the caret. */
+export function planEnter(source, from, to, options) {
+    return new Enter(source, options).plan(from, to);
+}

package/dist/fold-roles.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentLine } from './rope.ts';
+import type { FoldHints, FoldRole, FoldingRange } from './structure.ts';
+export declare function commentRole(slice: (from: number, to: number) => string, from: number, to: number): FoldRole | undefined;
+export declare function bracketRole(slice: (from: number, to: number) => string, from: number, language: string): FoldRole | undefined;
+export declare function markFileHeader(ranges: FoldingRange[], getLine: (line: number) => DocumentLine, lineCount: number, language: string): void;
+export declare function applyFoldHints(ranges: readonly FoldingRange[], hints: FoldHints, lineAt: (offset: number) => number, getLine: (line: number) => DocumentLine, slice: (from: number, to: number) => string, minimum: number): FoldingRange[];

package/dist/fold-roles.js

@@ -0,0 +1,142 @@
+import { isImportLine } from './lexical-folds.js';
+const SCRIPT_LANGUAGES = /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|mjs|cjs|mts|cts)$/i;
+/* How far back from a bracket the text before it is read. */
+const LOOK_BEHIND = 200;
+/* A file header sits at the top, behind at most a shebang or an open tag and a blank line or two. */
+const HEADER_LINES = 4;
+/* Words an expression can follow, so a bracket after one is a value and not a block. */
+const VALUE_WORDS = /\b(?:return|default|yield|await|of|in)$/;
+/* A block comment that opens with two stars is documentation; `/**` closed at once is an empty one. */
+export function commentRole(slice, from, to) {
+    return to - from > 4 && slice(from, from + 3) === '/**' ? 'doc-comment' : undefined;
+}
+/*
+ * Whether a bracket opens an array or an object literal in a script, or a PHP attribute list, read from what
+ * comes before it. A block (`) {`, `else {`) and an index (`items[`) have a word or a closer in front of them.
+ */
+export function bracketRole(slice, from, language) {
+    const opener = slice(from, from + 1);
+    const before = slice(Math.max(0, from - LOOK_BEHIND), from);
+    if (language.toLowerCase() === 'php') {
+        return opener === '[' && before.endsWith('#') ? 'attribute' : undefined;
+    }
+    if (!SCRIPT_LANGUAGES.test(language) || (opener !== '{' && opener !== '[')) {
+        return undefined;
+    }
+    const head = before.slice(before.lastIndexOf('\n') + 1);
+    const trimmed = before.trimEnd();
+    const previous = trimmed.at(-1);
+    if (previous === undefined) {
+        return undefined;
+    }
+    const arrow = trimmed.endsWith('=>');
+    const value = (/[=:(,[?]/.test(previous) && !arrow) || VALUE_WORDS.test(trimmed) || (arrow && opener === '[');
+    if (!value) {
+        return undefined;
+    }
+    if (opener === '[') {
+        return 'array-literal';
+    }
+    // A `case x: {` and a `type A = {` are a block and a type, not a value.
+    return /^\s*(?:case\b|default\s*:|(?:export\s+)?(?:declare\s+)?(?:type|interface)\b)/.test(head) ? undefined : 'object-literal';
+}
+function isBlank(text) {
+    return text.trim() === '';
+}
+/*
+ * The comment at the very top of a file is its header, unless it is the documentation of what follows
+ * right under it. Only the first comment can be one, and only behind a shebang, an open tag or blank lines.
+ */
+export function markFileHeader(ranges, getLine, lineCount, language) {
+    const candidate = ranges.find((range) => (range.kind === 'comment' || range.kind === 'line-comments') && range.startLine <= HEADER_LINES);
+    if (candidate === undefined) {
+        return;
+    }
+    for (let line = 0; line < candidate.startLine; line++) {
+        const text = getLine(line).text;
+        if (!isBlank(text) && !(line === 0 && /^(#!|<\?php\s*$)/.test(text))) {
+            return;
+        }
+    }
+    const start = getLine(candidate.startLine);
+    if (candidate.from > start.start + (start.text.length - start.text.trimStart().length)) {
+        return;
+    }
+    const next = candidate.endLine + 1 < lineCount ? getLine(candidate.endLine + 1).text : '';
+    const attached = candidate.role === 'doc-comment' && !isBlank(next) && !isImportLine(language, next.trimStart());
+    if (!attached) {
+        candidate.role = 'file-header';
+    }
+}
+/* The role a language server's range kind says, when the text under it says nothing else. */
+function serverRole(kind, text) {
+    if (kind === 'imports') {
+        return 'imports';
+    }
+    if (kind === 'region') {
+        return 'region';
+    }
+    if (kind === 'comment') {
+        return text.startsWith('/**') ? 'doc-comment' : undefined;
+    }
+    return text.startsWith('<') ? 'tag' : undefined;
+}
+/*
+ * What a language server adds to the folds the text gives. A symbol names the body among the brackets: the
+ * pair that closes where it ends, or the indented block that does. A range the text has no fold for becomes a
+ * fold of its own, one per line it starts on, so the server's `{` block is not a second fold under the pair.
+ */
+export function applyFoldHints(ranges, hints, lineAt, getLine, slice, minimum) {
+    const result = ranges.map((range) => ({ ...range }));
+    for (const symbol of hints.symbols ?? []) {
+        const startLine = lineAt(symbol.from);
+        const endLine = lineAt(Math.max(symbol.from, symbol.to - 1));
+        const body = bodyOf(result, symbol, startLine, endLine, slice);
+        if (body !== undefined) {
+            body.range.role = body.role;
+        }
+    }
+    const starts = new Set(result.map((range) => range.startLine));
+    for (const hint of hints.ranges ?? []) {
+        const startLine = lineAt(hint.from);
+        const endLine = lineAt(hint.to);
+        if (endLine - startLine < minimum || starts.has(startLine)) {
+            continue;
+        }
+        const first = getLine(startLine);
+        const indent = first.text.length - first.text.trimStart().length;
+        const role = serverRole(hint.kind, first.text.trimStart());
+        starts.add(startLine);
+        result.push({
+            startLine,
+            endLine,
+            from: first.start + indent,
+            to: getLine(endLine).end,
+            kind: 'server',
+            ...(role === undefined ? {} : { role })
+        });
+    }
+    return result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
+}
+/* The fold that is the body of a symbol, and what kind of body it is. */
+function bodyOf(ranges, symbol, startLine, endLine, slice) {
+    const brace = ranges
+        .filter((range) => range.kind === 'bracket' && range.from >= symbol.from && range.to <= symbol.to && slice(range.from, range.from + 1) === '{')
+        .filter((range) => /^[\s;,]*$/.test(slice(range.to, symbol.to)))
+        .sort((left, right) => right.to - left.to || left.from - right.from)[0];
+    const range = brace ??
+        ranges
+            .filter((candidate) => candidate.kind === 'indentation' && candidate.endLine === endLine && candidate.startLine >= startLine)
+            .sort((left, right) => left.startLine - right.startLine)[0];
+    if (range === undefined) {
+        return undefined;
+    }
+    if (symbol.body === 'class') {
+        return { range, role: 'class-body' };
+    }
+    if (symbol.body === 'value') {
+        const signature = slice(symbol.from, range.from);
+        return /=>|\bfunction\b/.test(signature) ? { range, role: 'function-body' } : undefined;
+    }
+    return { range, role: symbol.body === 'method' ? 'method-body' : 'function-body' };
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { DocumentModel } from './document.ts';
+export type { DocumentEditOptions, DocumentLine, OffsetRange, ReplaceAllOptions, ReplaceOptions, TypeTextOptions } from './document.ts';
+export { scanBrackets, type BracketIndex } from './brackets.ts';
+export { replaceWithCaseRespect } from './preserve-case.ts';
+export { findMatches, replacementText, type FindMatch, type FindNextOptions, type FindOptions } from './search.ts';
+export { indentationColumn } from './structure.ts';
+export type { FoldHints, FoldRangeHint, FoldRole, FoldSymbolHint, FoldingOptions, FoldingRange } from './structure.ts';
+export { isHumpBoundary, isWordBoundary, wordBoundary, type WordText } from './words.ts';
+export type { ChangeSource, CommandOptions, ContentEdit, Disposable, DocumentChange, EditOptions, EditorCommand, EditorSnapshot, Position, Selection, TextEdit } from './types.ts';
+export { changedSpan, changedSpans, type TextSpan } from './text-span.ts';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { DocumentModel } from './document.js';
+export { scanBrackets } from './brackets.js';
+export { replaceWithCaseRespect } from './preserve-case.js';
+export { findMatches, replacementText } from './search.js';
+export { indentationColumn } from './structure.js';
+export { isHumpBoundary, isWordBoundary, wordBoundary } from './words.js';
+export { changedSpan, changedSpans } from './text-span.js';

package/dist/languages.d.ts

@@ -0,0 +1,12 @@
+export interface BlockComment {
+    open: string;
+    close: string;
+}
+export interface CommentSyntax {
+    line: string | null;
+    block: BlockComment | null;
+}
+export type VueRegion = 'template' | 'script' | 'style';
+export declare function commentSyntax(language: string, region?: VueRegion | null): CommentSyntax;
+export declare function isPlainText(language: string): boolean;
+export declare function vueRegionAt(lineText: (line: number) => string, line: number): VueRegion | null;

package/dist/languages.js

@@ -0,0 +1,51 @@
+const slashStar = { open: '/*', close: '*/' };
+const html = { open: '<!--', close: '-->' };
+const cLike = { line: '//', block: slashStar };
+const hash = { line: '#', block: null };
+const markup = { line: null, block: html };
+const none = { line: null, block: null };
+const syntaxes = new Map();
+function register(ids, syntax) {
+    for (const id of ids.split(' ')) {
+        syntaxes.set(id, syntax);
+    }
+}
+register('typescript javascript typescriptreact javascriptreact tsx jsx ts js mjs cjs mts cts java c cpp c++ csharp cs go rust rs swift kotlin kt scala dart php scss less zig groq json jsonc json5 prisma astro svelte objective-c objc glsl hlsl proto protobuf hcl terraform', cLike);
+register('css', { line: null, block: slashStar });
+register('html xml svg xsl markdown md mdx vue', markup);
+register('python py yaml yml shellscript shell sh bash zsh fish toml ruby rb perl r make makefile docker dockerfile dotenv ignore nix graphql powershell ps1 properties julia jl elixir ex exs coffeescript coffee cmake', hash);
+register('ini', { line: ';', block: null });
+register('sql', { line: '--', block: slashStar });
+register('lua', { line: '--', block: { open: '--[[', close: ']]' } });
+register('haskell hs', { line: '--', block: { open: '{-', close: '-}' } });
+register('plaintext text txt log', none);
+/* An id nothing knows has no comment syntax, which toggling a comment answers by doing nothing. */
+export function commentSyntax(language, region) {
+    const id = language.toLowerCase();
+    if (id === 'vue') {
+        if (region === 'script') {
+            return cLike;
+        }
+        return region === 'style' ? { line: null, block: slashStar } : markup;
+    }
+    return syntaxes.get(id) ?? none;
+}
+/* Plain text has no structure to pair, indent or comment. */
+export function isPlainText(language) {
+    return /^(plaintext|text|txt|log)$/i.test(language);
+}
+/* The region of a `.vue` file a line is in, from the top-level tags above it. */
+export function vueRegionAt(lineText, line) {
+    let region = null;
+    for (let index = 0; index <= line; index++) {
+        const text = lineText(index);
+        const open = /^<(template|script|style)\b/.exec(text);
+        if (open) {
+            region = open[1];
+        }
+        else if (/^<\/(template|script|style)\s*>/.test(text) && index < line) {
+            region = null;
+        }
+    }
+    return region;
+}