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

package/src/languages.ts

@@ -0,0 +1,77 @@
+export interface BlockComment {
+    open: string;
+    close: string;
+}
+
+/* Either marker can be missing: CSS has no line comments and Python no block comments. */
+export interface CommentSyntax {
+    line: string | null;
+    block: BlockComment | null;
+}
+
+/* The part of a Vue single file component a line sits in. */
+export type VueRegion = 'template' | 'script' | 'style';
+
+const slashStar: BlockComment = { open: '/*', close: '*/' };
+const html: BlockComment = { open: '<!--', close: '-->' };
+
+const cLike: CommentSyntax = { line: '//', block: slashStar };
+const hash: CommentSyntax = { line: '#', block: null };
+const markup: CommentSyntax = { line: null, block: html };
+const none: CommentSyntax = { line: null, block: null };
+
+const syntaxes = new Map<string, CommentSyntax>();
+
+function register(ids: string, syntax: CommentSyntax): void {
+    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: string, region?: VueRegion | null): CommentSyntax {
+    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: string): boolean {
+    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: number) => string, line: number): VueRegion | null {
+    let region: VueRegion | null = 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] as VueRegion;
+        } else if (/^<\/(template|script|style)\s*>/.test(text) && index < line) {
+            region = null;
+        }
+    }
+    return region;
+}

package/src/lexical-folds.ts

@@ -0,0 +1,138 @@
+import { commentSyntax } from './languages.ts';
+import type { FoldRole, FoldingRange } from './structure.ts';
+import type { DocumentLine } from './rope.ts';
+
+/* The words a line starts with when it brings another file in, by language. A language not listed here has no import list to fold. */
+const IMPORT_WORDS = new Map<string, RegExp>();
+
+function register(languages: string, words: string): void {
+    // The word must stand alone, and `import(` and `import.meta` are expressions and not an import.
+    const pattern = new RegExp(`^(?:${words})\\b(?![(.=,;:])`);
+    for (const language of languages.split(' ')) {
+        IMPORT_WORDS.set(language, pattern);
+    }
+}
+
+register(
+    'typescript javascript typescriptreact javascriptreact tsx jsx ts js mjs cjs mts cts vue svelte astro java kotlin scala groovy go swift dart haskell elm',
+    'import'
+);
+register('python py', 'import|from');
+register('php rust rs perl', 'use');
+register('csharp cs', 'using');
+
+/* Whether a line, without its indentation, brings another file in. */
+export function isImportLine(language: string, trimmed: string): boolean {
+    return IMPORT_WORDS.get(language.toLowerCase())?.test(trimmed) ?? false;
+}
+
+const REGION_START = /^\s*(?:\/\/|#|<!--|\/\*|--)\s*(?:#\s*)?region\b/;
+const REGION_END = /^\s*(?:\/\/|#|<!--|\/\*|--)\s*(?:#\s*)?endregion\b/;
+
+export interface LexicalFoldOptions {
+    /* Each on unless false. */
+    imports?: boolean;
+    regions?: boolean;
+    lineComments?: boolean;
+}
+
+function bracketDelta(text: string): number {
+    let depth = 0;
+    for (const character of text) {
+        if (character === '{' || character === '(' || character === '[') {
+            depth++;
+        } else if (character === '}' || character === ')' || character === ']') {
+            depth--;
+        }
+    }
+    return depth;
+}
+
+/* A fold of whole lines, from the end of the first to the end of the last. */
+export function rangeOf(
+    startLine: number,
+    endLine: number,
+    getLine: (line: number) => DocumentLine,
+    kind: FoldingRange['kind'],
+    role?: FoldRole
+): FoldingRange {
+    const start = getLine(startLine);
+    return {
+        startLine,
+        endLine,
+        from: start.start + (start.text.length - start.text.trimStart().length),
+        to: getLine(endLine).end,
+        kind,
+        ...(role === undefined ? {} : { role })
+    };
+}
+
+/*
+ * The folds that come from how lines begin and need no syntax tree: a run of lines that import, a run
+ * of lines of line comments, and what sits between a `// region` line and its `// endregion`.
+ */
+export function lexicalFolds(lineCount: number, getLine: (line: number) => DocumentLine, language: string, options: LexicalFoldOptions = {}): FoldingRange[] {
+    const result: FoldingRange[] = [];
+    const id = language.toLowerCase();
+    const words = options.imports === false ? undefined : IMPORT_WORDS.get(id);
+    const marker = options.lineComments === false ? null : commentSyntax(id).line;
+    const regions: number[] = [];
+    let importStart = -1;
+    let importEnd = -1;
+    let commentStart = -1;
+    let commentEnd = -1;
+    const flushImports = (): void => {
+        if (importStart !== -1 && importEnd > importStart) {
+            result.push(rangeOf(importStart, importEnd, getLine, 'imports', 'imports'));
+        }
+        importStart = -1;
+    };
+    const flushComments = (): void => {
+        if (commentStart !== -1 && commentEnd > commentStart) {
+            result.push(rangeOf(commentStart, commentEnd, getLine, 'line-comments'));
+        }
+        commentStart = -1;
+    };
+    for (let line = 0; line < lineCount; line++) {
+        const text = getLine(line).text;
+        const trimmed = text.trimStart();
+        const isRegionMarker = options.regions !== false && (REGION_START.test(text) || REGION_END.test(text));
+        if (isRegionMarker) {
+            flushComments();
+            if (REGION_START.test(text)) {
+                regions.push(line);
+            } else {
+                const start = regions.pop();
+                if (start !== undefined && line > start) {
+                    result.push(rangeOf(start, line, getLine, 'region', 'region'));
+                }
+            }
+            continue;
+        }
+        if (marker !== null && trimmed.startsWith(marker)) {
+            commentStart = commentStart === -1 ? line : commentStart;
+            commentEnd = line;
+        } else {
+            flushComments();
+        }
+        if (words === undefined) {
+            continue;
+        }
+        if (words.test(trimmed)) {
+            let last = line;
+            let depth = bracketDelta(text);
+            while (depth > 0 && last + 1 < lineCount) {
+                last++;
+                depth += bracketDelta(getLine(last).text);
+            }
+            importStart = importStart === -1 ? line : importStart;
+            importEnd = last;
+            line = last;
+        } else if (trimmed !== '' && !(marker !== null && trimmed.startsWith(marker))) {
+            flushImports();
+        }
+    }
+    flushComments();
+    flushImports();
+    return result;
+}

package/src/lexical.ts

@@ -0,0 +1,113 @@
+export const openers: Readonly<Record<string, string>> = { '(': ')', '[': ']', '{': '}' };
+
+/* Words after which a `/` starts a regex and a `{` an object or a block, not a division or a statement end. */
+const expressionWords = /^(return|throw|case|yield|await|new|delete|typeof|void|in|of|instanceof)$/;
+
+/* Whether a `#` at this index stands where a word would start, after whitespace, a separator or an opener. */
+export function startsWord(text: string, at: number): boolean {
+    return at === 0 || /[\s;|&(]/.test(text[at - 1]!);
+}
+
+/*
+ * What a language's comments and braces look like to the lexer. The lists are positive: a language
+ * nobody listed has no comment syntax, so a `/*` in a YAML value or a `#` in shell never reads as
+ * the wrong comment for the rest of the file. The ids are the ones Shiki gives the editor.
+ */
+interface LanguageRules {
+    slash: boolean;
+    /* `any` is a comment wherever it stands, `boundary` only at the start of a word, as in shell and YAML. */
+    hash: false | 'any' | 'boundary';
+    dash: boolean;
+    block: boolean;
+    markup: boolean;
+    /* Blocks are in braces, so a statement may be left open and a `case` label opens a block. */
+    braced: boolean;
+}
+
+const NO_RULES: LanguageRules = { slash: false, hash: false, dash: false, block: false, markup: false, braced: false };
+const languageRules = new Map<string, LanguageRules>();
+
+function register(ids: string, rules: Partial<LanguageRules>): void {
+    for (const id of ids.split(' ')) {
+        languageRules.set(id, { ...NO_RULES, ...rules });
+    }
+}
+
+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 zig groq prisma astro svelte objective-c objc glsl hlsl proto protobuf scss less jsonc json5',
+    { slash: true, block: true, braced: true }
+);
+register('php', { slash: true, hash: 'any', block: true, braced: true });
+register('vue', { slash: true, block: true, markup: true, braced: true });
+register('hcl terraform', { slash: true, hash: 'any', block: true, braced: true });
+register('css', { block: true });
+register('html xml svg xsl markdown md mdx', { markup: true });
+register('python py toml ruby rb dotenv ignore nix powershell ps1 properties julia jl elixir ex exs coffeescript coffee', { hash: 'any' });
+register('shellscript shell sh bash zsh fish yaml yml make makefile docker dockerfile cmake', { hash: 'boundary' });
+register('perl r graphql', { hash: 'any', braced: true });
+register('sql', { dash: true, block: true });
+register('lua haskell hs', { dash: true });
+
+function rulesOf(language: string): LanguageRules {
+    return languageRules.get(language.toLowerCase()) ?? NO_RULES;
+}
+
+export function isScript(language: string): boolean {
+    return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|vue)$/i.test(language);
+}
+
+export function isPhp(language: string): boolean {
+    return /^php$/i.test(language);
+}
+
+export function hasHashComments(language: string): boolean {
+    return rulesOf(language).hash !== false;
+}
+
+/* Whether a `#` only starts a comment at the start of a word, which keeps `$#` and `${#list}` in shell code. */
+export function hashNeedsWordStart(language: string): boolean {
+    return rulesOf(language).hash === 'boundary';
+}
+
+export function hasDashComments(language: string): boolean {
+    return rulesOf(language).dash;
+}
+
+export function hasBlockComments(language: string): boolean {
+    return rulesOf(language).block;
+}
+
+export function hasSlashComments(language: string): boolean {
+    return rulesOf(language).slash;
+}
+
+export function hasMarkupComments(language: string): boolean {
+    return rulesOf(language).markup;
+}
+
+/* Languages whose blocks are in braces: where a statement can be left open and a `case` label opens a block. */
+export function isBraced(language: string): boolean {
+    return rulesOf(language).braced;
+}
+
+/* Languages whose indentation follows their brackets, which Auto-indent Lines can work out. */
+export function indentsByBrackets(language: string): boolean {
+    return (isBraced(language) && !/^(svelte|astro)$/i.test(language)) || /^css$/i.test(language);
+}
+
+export function hasSmartSemicolon(language: string): boolean {
+    return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|php)$/i.test(language);
+}
+
+export function isWordCharacter(character: string): boolean {
+    return /[\p{L}\p{N}_$]/u.test(character);
+}
+
+export function startsExpression(word: string): boolean {
+    return expressionWords.test(word);
+}
+
+/* Whether what follows a punctuation character is an expression, so a `/` there is a regex. */
+export function startsExpressionAfter(character: string): boolean {
+    return /[=,:;!?+\-*%&|^~<>]/.test(character);
+}

package/src/line-commands.ts

@@ -0,0 +1,356 @@
+import type { EditPlan, EditSource } from './edit-source.ts';
+import { commentSyntax } from './languages.ts';
+import { continues } from './enter.ts';
+import { indentsByBrackets } from './lexical.ts';
+import { markupGuard } from './markup-regions.ts';
+import { mapOffset } from './offsets.ts';
+import type { Selection, TextEdit } from './types.ts';
+import type { TypingContext } from './typing-context.ts';
+
+export interface LineCommandOptions {
+    language: string;
+    /* One level of indentation. */
+    unit: string;
+}
+
+const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
+
+function rangeOf(selection: Selection): { from: number; to: number } {
+    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
+}
+
+function whitespaceOf(text: string): string {
+    return /^[\t ]*/.exec(text)![0];
+}
+
+function isBlank(text: string): boolean {
+    return text.trim() === '';
+}
+
+/* How far the edits in front of an offset moved it. An edit that starts at the offset is not in front of it. */
+function shiftBefore(offset: number, edits: readonly TextEdit[]): number {
+    return edits.filter((edit) => edit.from < offset).reduce((sum, edit) => sum + edit.text.length - (Math.min(edit.to, offset) - edit.from), 0);
+}
+
+/* The offset of the first character after `from` that is not whitespace, line breaks included. */
+function skipWhitespace(source: EditSource, from: number): number {
+    const last = source.line(source.lineCount - 1).end;
+    let offset = from;
+    while (offset < last && /\s/.test(source.charAt(offset))) {
+        offset++;
+    }
+    return offset;
+}
+
+/* What goes where two lines meet: nothing before a closer, a comma or a dot and after an opener, else a space. */
+function spacingBetween(previous: string, next: string): string {
+    if (next === '' || /^[)\],;]/.test(next) || /^\.(?![.\d])/.test(next) || /[([]$/.test(previous)) {
+        return '';
+    }
+    return ' ';
+}
+
+interface Join {
+    from: number;
+    to: number;
+    text: string;
+    /* Where the caret goes in the text, which is where the lines were split. */
+    caret: number;
+}
+
+/* The comment a line ends in, as its start and the marker it opens with. */
+function endComment(source: EditSource, options: LineCommandOptions, line: number): { start: number; marker: string } | null {
+    const bounds = source.line(line);
+    const syntax = commentSyntax(options.language, source.region(line));
+    const context = source.context(bounds.end);
+    if (context.mode !== 'line-comment' || context.commentStart === undefined || context.commentStart < bounds.start || syntax.line === null) {
+        return null;
+    }
+    return { start: context.commentStart, marker: syntax.line };
+}
+
+/* One join of a line with the next content after it. */
+function joinAfter(source: EditSource, options: LineCommandOptions, index: number): Join | null {
+    const left = source.line(index);
+    const next = skipWhitespace(source, left.end);
+    const trimmedEnd = left.start + left.text.trimEnd().length;
+    const nextLine = source.line(source.lineAt(next));
+    const content = source.slice(next, nextLine.end).trimEnd();
+    if (isBlank(left.text)) {
+        return { from: left.start, to: nextLine.start, text: '', caret: whitespaceOf(nextLine.text).length };
+    }
+    const comment = endComment(source, options, index);
+    if (comment) {
+        const marker = comment.marker.trimEnd();
+        if (content.startsWith(marker)) {
+            const rest = content.slice(marker.length);
+            const dropped = next + marker.length + (rest.startsWith(' ') ? 1 : 0);
+            const remainder = rest.startsWith(' ') ? rest.slice(1) : rest;
+            return { from: trimmedEnd, to: dropped, text: remainder === '' ? '' : ' ', caret: 0 };
+        }
+    }
+    return { from: trimmedEnd, to: next, text: spacingBetween(source.slice(left.start, trimmedEnd), content), caret: 0 };
+}
+
+/*
+ * Joins each line with the next, or the lines of a selection into one. The break and the whitespace
+ * around it become a space, a `//` comment line joined to another loses its second marker and the
+ * end of line comment of a line that code follows becomes a block comment.
+ */
+export function planJoinLines(source: EditSource, selections: readonly Selection[], options: LineCommandOptions): EditPlan | null {
+    interface Range {
+        first: number;
+        count: number;
+    }
+    const ranges: Range[] = [];
+    for (const selection of selections) {
+        const { from, to } = rangeOf(selection);
+        const first = source.lineAt(from);
+        let last = from === to ? first + 1 : source.lineAt(to);
+        if (from !== to && last > first && source.line(last).start === to) {
+            last--;
+        }
+        if (last >= source.lineCount) {
+            continue;
+        }
+        const previous = ranges.at(-1);
+        if (previous && first <= previous.first + previous.count) {
+            previous.count = Math.max(previous.count, last - previous.first);
+        } else {
+            ranges.push({ first, count: last - first });
+        }
+    }
+    const edits: TextEdit[] = [];
+    const carets: { at: number; extra: number }[] = [];
+    for (const range of ranges) {
+        let line = range.first;
+        for (let done = 0; done < range.count && line < source.lineCount - 1; done++) {
+            const join = joinAfter(source, options, line);
+            if (!join) {
+                break;
+            }
+            const comment = endComment(source, options, line);
+            const nextStart = skipWhitespace(source, source.line(line).end);
+            const nextLine = source.line(source.lineAt(nextStart));
+            const converts =
+                comment !== null &&
+                !isBlank(source.slice(source.line(line).start, comment.start)) &&
+                !source.slice(nextStart, nextLine.end).startsWith(comment.marker.trimEnd()) &&
+                commentSyntax(options.language, source.region(line)).block?.open === '/*';
+            if (converts && comment) {
+                const body = source.slice(comment.start + comment.marker.length, join.from);
+                if (!body.includes('*/')) {
+                    edits.push({ from: comment.start, to: comment.start + comment.marker.length, text: '/*' });
+                    const closing = (body.startsWith(' ') && !body.endsWith(' ') ? ' ' : '') + '*/';
+                    edits.push({ from: join.from, to: join.to, text: closing + join.text });
+                    carets.push({ at: join.from, extra: closing.length });
+                    line = source.lineAt(nextStart);
+                    continue;
+                }
+            }
+            edits.push({ from: join.from, to: join.to, text: join.text });
+            carets.push({ at: join.from, extra: join.caret });
+            line = source.lineAt(nextStart);
+        }
+    }
+    if (edits.length === 0) {
+        return null;
+    }
+    edits.sort((left, right) => left.from - right.from);
+    const result = selections.map((selection) => {
+        const { from, to } = rangeOf(selection);
+        if (from !== to) {
+            const end = mapOffset(to, edits);
+            return { anchor: end, head: end };
+        }
+        const line = source.line(source.lineAt(from));
+        const caret = carets.find((entry) => entry.at >= line.start && entry.at <= line.end);
+        const base = caret ? caret.at + shiftBefore(caret.at, edits) + caret.extra : mapOffset(from, edits);
+        return { anchor: base, head: base };
+    });
+    return { edits, selections: result };
+}
+
+/* The identifier characters around an offset. */
+function wordAround(source: EditSource, offset: number): { from: number; to: number } {
+    const line = source.line(source.lineAt(offset));
+    const column = offset - line.start;
+    let from = column;
+    let to = column;
+    while (from > 0 && identifier.test(line.text[from - 1]!)) {
+        from--;
+    }
+    while (to < line.text.length && identifier.test(line.text[to]!)) {
+        to++;
+    }
+    return { from: line.start + from, to: line.start + to };
+}
+
+/* A string escape such as `\n` stays as written. */
+function convertCase(text: string, lower: boolean, inString: boolean): string {
+    const convert = (part: string): string => (lower ? part.toLowerCase() : part.toUpperCase());
+    if (!inString) {
+        return convert(text);
+    }
+    return text
+        .split(/(\\(?:u\{[0-9a-fA-F]+\}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|.))/)
+        .map((part, index) => (index % 2 === 1 ? part : convert(part)))
+        .join('');
+}
+
+/*
+ * Flips the case of what is selected, or of the word at a caret with nothing selected, which stays
+ * selected. Text with any capital turns to lower case, and text without turns to upper case; with
+ * several carets one answer goes for all of them.
+ */
+export function planToggleCase(source: EditSource, selections: readonly Selection[]): EditPlan | null {
+    const targets = selections.map((selection) => {
+        const { from, to } = rangeOf(selection);
+        return from === to ? { ...wordAround(source, from), word: true } : { from, to, word: false };
+    });
+    const texts = targets.map((target) => source.slice(target.from, target.to));
+    const lower = texts.some((text) => text !== text.toLowerCase());
+    const edits: TextEdit[] = [];
+    const result: Selection[] = [];
+    let delta = 0;
+    for (const [index, target] of targets.entries()) {
+        const context: TypingContext = source.context(target.from);
+        const inString = context.mode === 'quote' || context.mode === 'template';
+        const converted = convertCase(texts[index]!, lower, inString);
+        if (converted !== texts[index]) {
+            edits.push({ from: target.from, to: target.to, text: converted });
+        }
+        const selection = selections[index]!;
+        const reversed = selection.anchor > selection.head;
+        const start = target.from + delta;
+        const end = target.from + delta + converted.length;
+        result.push(target.word || !reversed ? { anchor: start, head: end } : { anchor: end, head: start });
+        delta += converted.length - texts[index]!.length;
+    }
+    if (targets.every((target) => target.from === target.to)) {
+        return null;
+    }
+    return { edits, selections: result };
+}
+
+interface Frame {
+    opener: number;
+    closer: string;
+}
+
+/* The brackets still open at the start of a line, innermost first. */
+function frames(context: TypingContext): Frame[] {
+    const result: Frame[] = [];
+    for (let bracket = context.bracket; bracket; bracket = bracket.previous) {
+        result.push({ opener: bracket.at, closer: bracket.close });
+    }
+    return result;
+}
+
+const caseLabel = /^(?:case\b[^]*|default)\s*:$/;
+
+/*
+ * Sets the indentation of the lines to what their brackets say: a line is one level in from the line
+ * its innermost bracket opened on, a closing bracket lines up with it, the lines of a case follow
+ * their label and a line after an unfinished statement goes in once. Lines in comments and strings,
+ * and in languages that are not bracketed, are left alone.
+ */
+export function planAutoIndent(source: EditSource, lines: readonly number[], options: LineCommandOptions): EditPlan | null {
+    if (!indentsByBrackets(options.language)) {
+        return null;
+    }
+    const indents = new Map<number, string>();
+    const indentOf = (line: number): string => indents.get(line) ?? whitespaceOf(source.line(line).text);
+    const edits: TextEdit[] = [];
+    const isMarkup = markupGuard(source, options.language);
+    for (const line of lines) {
+        const bounds = source.line(line);
+        const context = source.context(bounds.start);
+        if (isBlank(bounds.text) || context.mode !== 'code' || isMarkup(line)) {
+            continue;
+        }
+        const target = targetIndent(source, options, line, context, indentOf);
+        indents.set(line, target);
+        const current = whitespaceOf(bounds.text);
+        if (current !== target) {
+            edits.push({ from: bounds.start, to: bounds.start + current.length, text: target });
+        }
+    }
+    return edits.length === 0 ? null : { edits, selections: [] };
+}
+
+function targetIndent(source: EditSource, options: LineCommandOptions, line: number, context: TypingContext, indentOf: (line: number) => string): string {
+    const text = source.line(line).text.trimStart();
+    const open = frames(context);
+    const innermost = open[0];
+    if (innermost && text.startsWith(innermost.closer)) {
+        return indentOf(source.lineAt(innermost.opener));
+    }
+    let base = innermost ? indentOf(source.lineAt(innermost.opener)) + options.unit : '';
+    if (innermost?.closer === '}' && !caseLabel.test(text)) {
+        const label = openCaseLabel(source, line, context.bracket);
+        if (label !== null) {
+            base = indentOf(label) + options.unit;
+        }
+    }
+    const previous = previousCodeLine(source, line);
+    if (previous !== null && source.context(source.line(previous).start).bracket === context.bracket && lineContinues(source, options, previous)) {
+        return isContinuation(source, options, previous) ? indentOf(previous) : indentOf(previous) + options.unit;
+    }
+    return base;
+}
+
+function lineContinues(source: EditSource, options: LineCommandOptions, line: number): boolean {
+    const bounds = source.line(line);
+    const text = bounds.text.trimEnd();
+    return text.length > 0 && continues(text, source.context(bounds.start + text.length), options.language);
+}
+
+/* Whether the line goes on with a statement the line before it left open. */
+function isContinuation(source: EditSource, options: LineCommandOptions, line: number): boolean {
+    const previous = previousCodeLine(source, line);
+    return (
+        previous !== null &&
+        source.context(source.line(previous).start).bracket === source.context(source.line(line).start).bracket &&
+        lineContinues(source, options, previous)
+    );
+}
+
+function previousCodeLine(source: EditSource, line: number): number | null {
+    for (let candidate = line - 1; candidate >= 0; candidate--) {
+        if (!isBlank(source.line(candidate).text)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+
+/* Whether `bracket` is `outer` or sits inside it. */
+function within(bracket: TypingContext['bracket'], outer: TypingContext['bracket']): boolean {
+    for (let current = bracket; ; current = current.previous) {
+        if (current === outer) {
+            return true;
+        }
+        if (!current) {
+            return false;
+        }
+    }
+}
+
+/* The line of the `case` label the lines of this block run under, if there is one. */
+function openCaseLabel(source: EditSource, line: number, block: TypingContext['bracket']): number | null {
+    for (let candidate = line - 1; candidate >= 0 && candidate >= line - 200; candidate--) {
+        const bounds = source.line(candidate);
+        if (isBlank(bounds.text)) {
+            continue;
+        }
+        const state = source.context(bounds.start).bracket;
+        if (!within(state, block)) {
+            return null;
+        }
+        if (state === block && caseLabel.test(bounds.text.trim())) {
+            return candidate;
+        }
+    }
+    return null;
+}