@adecore/editor-core 0.43.0 → 0.44.1

package/dist/surround-shape.js

@@ -0,0 +1,127 @@
+import { lineContinues } from './enter.js';
+import { skipTriviaBack } from './trivia.js';
+const KEYWORDS = new Set([
+    'if',
+    'else',
+    'for',
+    'foreach',
+    'while',
+    'do',
+    'try',
+    'catch',
+    'finally',
+    'switch',
+    'case',
+    'default',
+    'return',
+    'throw',
+    'break',
+    'continue',
+    'const',
+    'let',
+    'var',
+    'function',
+    'class',
+    'interface',
+    'enum',
+    'import',
+    'export',
+    'echo',
+    'use',
+    'namespace',
+    'abstract',
+    'final'
+]);
+/* Whether a statement can start at the offset: after `;`, a block, a control statement's head, `else` or `do`, or on a line the one above leaves closed. */
+export function atStatementStart(source, offset, language) {
+    const context = source.context(offset);
+    const bracket = context.bracket;
+    // Inside parentheses, brackets or an object literal a new line starts an element, not a statement.
+    if (context.mode !== 'code' || (bracket !== undefined && !(bracket.close === '}' && bracket.block === true && bracket.template !== true))) {
+        return false;
+    }
+    if (context.word === 'control-close' || context.word === 'else' || context.word === 'do') {
+        return true;
+    }
+    const before = skipTriviaBack(source, offset);
+    if (before === 0) {
+        return true;
+    }
+    const last = source.charAt(before - 1);
+    if (last === ';' || (last === '{' && bracket?.at === before - 1)) {
+        return true;
+    }
+    if (last === '}') {
+        const opener = source.context(before - 1).bracket;
+        if (opener?.block === true && opener.template !== true) {
+            return true;
+        }
+    }
+    const line = source.line(source.lineAt(offset));
+    return source.slice(line.start, offset).trim() === '' && (line.start === 0 || !lineContinues(source, language, source.lineAt(offset) - 1));
+}
+/* Whether a statement ends at the offset: after `;` or `}`, or at the end of a line the statement does not go on after. */
+function atStatementEnd(source, offset, language) {
+    const last = source.charAt(offset - 1);
+    if (last === ';' || last === '}') {
+        return true;
+    }
+    const index = source.lineAt(offset);
+    return source.slice(offset, source.line(index).end).trim() === '' && !lineContinues(source, language, index);
+}
+/* Whether the range holds a `;` or a block at its own depth, which no expression does. */
+function holdsStatements(source, from, to) {
+    const bracket = source.context(from).bracket;
+    for (const match of source.slice(from, to).matchAll(/[;{]/g)) {
+        const at = from + match.index;
+        if (source.context(at).bracket?.at !== bracket?.at || source.context(at).mode !== 'code') {
+            continue;
+        }
+        if (match[0] === ';' || source.context(at + 1).bracket?.block === true) {
+            return true;
+        }
+    }
+    return false;
+}
+/* The line break of the range's last line, past a trailing line comment, or `to` when something else follows. */
+function widenedEnd(source, to) {
+    const line = source.line(source.lineAt(to));
+    const rest = source.slice(to, line.end);
+    if (rest.trim() === '') {
+        return to;
+    }
+    const context = source.context(line.end);
+    if (context.mode !== 'line-comment' || context.commentStart === undefined || context.commentStart < to) {
+        return to;
+    }
+    return source.slice(to, context.commentStart).trim() === '' ? to + rest.trimEnd().length : to;
+}
+/*
+ * What a range can be surrounded with: whole statements, one expression, both or neither. Both ends have to be code
+ * in the same bracket, and statements also start and end where a statement does.
+ */
+export function surroundShape(source, from, to, language) {
+    let start = from;
+    let end = to;
+    while (start < end && /\s/u.test(source.charAt(start))) {
+        start++;
+    }
+    while (end > start && /\s/u.test(source.charAt(end - 1))) {
+        end--;
+    }
+    if (start >= end) {
+        return null;
+    }
+    const first = source.context(start);
+    const last = source.context(end);
+    // Brackets are compared by position, since a scan makes new ones for the line it starts on.
+    if (first.mode !== 'code' || last.mode !== 'code' || first.bracket?.at !== last.bracket?.at) {
+        return { from: start, to: end, statements: false, expression: false };
+    }
+    const statements = atStatementStart(source, start, language) && atStatementEnd(source, end, language);
+    const wide = statements ? widenedEnd(source, end) : end;
+    const text = source.slice(start, end);
+    const word = /^[\p{L}_$][\p{L}\p{N}_$]*/u.exec(text)?.[0] ?? '';
+    const expression = wide === end && !/[\n\r]/.test(text) && !KEYWORDS.has(word) && !holdsStatements(source, start, end);
+    return { from: start, to: wide, statements, expression };
+}

package/dist/text-places.d.ts

@@ -0,0 +1,7 @@
+import type { EditSource } from './edit-source.ts';
+export type TextPlaceKind = 'code' | 'comment' | 'string';
+export interface TextPlace {
+    readonly language: string;
+    readonly kind: TextPlaceKind;
+}
+export declare function placeAt(source: EditSource, offset: number, language: string): TextPlace;

package/dist/text-places.js

@@ -0,0 +1,87 @@
+import { editRegions } from './edit-regions.js';
+import { vueRegionAt } from './languages.js';
+const SCAN_LIMIT = 2_000_000;
+const JSX_LANGUAGES = /^(?:typescriptreact|javascriptreact|tsx|jsx)$/;
+const VUE_TAG = /^<\/?(?:template|script|style)\b/;
+function kindOf(context) {
+    switch (context.mode) {
+        case 'line-comment':
+        case 'block-comment':
+        case 'html-comment':
+            return 'comment';
+        case 'quote':
+        case 'template':
+        case 'heredoc':
+        case 'regex':
+            return 'string';
+        case 'html':
+            if (context.markup === 'comment') {
+                return 'comment';
+            }
+            return context.markup === 'value' ? 'string' : 'code';
+        default:
+            return 'code';
+    }
+}
+/* The language of a `<script>` or `<style>` of a Vue file, read from the `lang` attribute of the tag that opened the region. */
+function vueRegionLanguage(source, line, region) {
+    for (let index = line; index >= 0; index--) {
+        const text = source.line(index).text;
+        if (!text.startsWith(`<${region}`)) {
+            continue;
+        }
+        const lang = /\blang\s*=\s*["']?([\w-]+)/.exec(text)?.[1]?.toLowerCase();
+        if (region === 'style') {
+            return lang === 'scss' || lang === 'less' ? lang : 'css';
+        }
+        return lang === 'ts' || lang === 'tsx' ? 'typescript' : 'javascript';
+    }
+    return region === 'style' ? 'css' : 'javascript';
+}
+function vueLanguage(source, offset) {
+    const line = source.lineAt(offset);
+    const region = VUE_TAG.test(source.line(line).text) ? null : vueRegionAt((index) => source.line(index).text, line);
+    return region === 'script' || region === 'style' ? vueRegionLanguage(source, line, region) : 'html';
+}
+/* Whether a `<script>` or `<style>` element is open at the offset in a plain markup document. */
+function markupLanguage(source, offset) {
+    let open = null;
+    for (const match of source.slice(0, offset).matchAll(/<(\/)?(script|style)\b[^>]*?(\/)?>/gi)) {
+        open = match[1] === undefined && match[3] === undefined ? match[2].toLowerCase() : null;
+    }
+    if (open === null) {
+        return 'html';
+    }
+    return open === 'script' ? 'javascript' : 'css';
+}
+function phpLanguage(context) {
+    if (context.embedded === 'javascript') {
+        return 'javascript';
+    }
+    if (context.mode !== 'html') {
+        return 'php';
+    }
+    return context.markup === 'raw' && context.element === 'style' ? 'css' : 'html';
+}
+/* What the text at an offset is written in and whether it is code, a comment or a string. */
+export function placeAt(source, offset, language) {
+    const id = language.toLowerCase();
+    if (source.line(source.lineCount - 1).end > SCAN_LIMIT) {
+        return { language, kind: 'code' };
+    }
+    const context = source.context(offset);
+    const kind = kindOf(context);
+    if (id === 'php') {
+        return { language: phpLanguage(context), kind };
+    }
+    if (id === 'vue') {
+        return { language: vueLanguage(source, offset), kind };
+    }
+    if (id === 'html' || id === 'xhtml') {
+        return { language: markupLanguage(source, offset), kind };
+    }
+    if (JSX_LANGUAGES.test(id) && editRegions(source, id)(source.lineAt(offset), offset) === 'jsx') {
+        return { language: 'html', kind };
+    }
+    return { language, kind };
+}

package/dist/trivia.d.ts

@@ -0,0 +1,2 @@
+import type { EditSource } from './edit-source.ts';
+export declare function skipTriviaBack(source: EditSource, end: number): number;

package/dist/trivia.js

@@ -0,0 +1,19 @@
+/* The end of the last token before `end`, past the whitespace and the comments between them. */
+export function skipTriviaBack(source, end) {
+    let at = end;
+    while (at > 0) {
+        const char = source.charAt(at - 1);
+        if (/\s/u.test(char)) {
+            at--;
+            continue;
+        }
+        // The lexer leaves a block comment at its `*`, so the state before the closing `/` is already code.
+        const inside = source.context(char === '/' && at > 1 && source.charAt(at - 2) === '*' ? at - 2 : at - 1);
+        if ((inside.mode === 'line-comment' || inside.mode === 'block-comment') && inside.commentStart !== undefined && inside.commentStart < at) {
+            at = inside.commentStart;
+            continue;
+        }
+        break;
+    }
+    return at;
+}

package/dist/types.d.ts

@@ -57,6 +57,7 @@ export interface CommandOptions {
     language?: string;
     smartSemicolon?: boolean;
     smartArrow?: boolean;
+    templateLiterals?: boolean;
     tabOutOfClosers?: boolean;
     smartEnter?: boolean;
     indentOnPaste?: boolean;

package/dist/typing-handlers.d.ts

@@ -1,4 +1,5 @@
 import type { EditSource } from './edit-source.ts';
+import type { TextEdit } from './types.ts';
 export interface HandlerEdit {
     from: number;
     to: number;
@@ -13,3 +14,8 @@ export declare function surround(selected: string, typed: string): {
     text: string;
     inner: string;
 };
+export declare function templateString(source: EditSource, offset: number, language: string): {
+    open: number;
+    close: number;
+} | null;
+export declare function templateLiteralEdits(source: EditSource, open: number, close: number): TextEdit[];

package/dist/typing-handlers.js

@@ -123,3 +123,66 @@ export function surround(selected, typed) {
     }
     return { text: typed + inner + matchingDelimiter(typed), inner };
 }
+const scriptLanguages = /^(javascript|typescript|jsx|tsx|javascriptreact|typescriptreact|js|ts|mjs|cjs|mts|cts)$/i;
+const moduleSpecifier = /(?:\bfrom|\bimport|\brequire)\s*\(?\s*$/;
+/*
+ * The quotes of the string a `${` is typed in when that makes it a template literal: a single- or
+ * double-quoted string of a script, closed on its line and not the specifier of a module.
+ */
+export function templateString(source, offset, language) {
+    const line = source.lineAt(offset);
+    const script = scriptLanguages.test(language) || (/^vue$/i.test(language) && source.region(line) === 'script');
+    const { start, end } = source.line(line);
+    const before = source.slice(start, offset);
+    if (!script || !before.endsWith('$') || escapedIn(before, before.length - 1)) {
+        return null;
+    }
+    const context = source.context(offset);
+    if (context.mode !== 'quote' || context.escaped || (context.quote !== "'" && context.quote !== '"')) {
+        return null;
+    }
+    let open = before.length - 1;
+    while (open >= 0 && (before[open] !== context.quote || escapedIn(before, open))) {
+        open--;
+    }
+    if (open < 0 || moduleSpecifier.test(before.slice(0, open))) {
+        return null;
+    }
+    const after = source.slice(offset, end);
+    for (let at = 0; at < after.length; at++) {
+        if (after[at] === '\\') {
+            at++;
+        }
+        else if (after[at] === context.quote) {
+            return { open: start + open, close: offset + at };
+        }
+    }
+    return null;
+}
+function escapedIn(text, index) {
+    let slashes = 0;
+    while (index - slashes - 1 >= 0 && text[index - slashes - 1] === '\\') {
+        slashes++;
+    }
+    return slashes % 2 === 1;
+}
+/* The edits that make the string between the quotes at `open` and `close` a template literal: its backticks are escaped and its escaped old quotes are not. */
+export function templateLiteralEdits(source, open, close) {
+    const quote = source.charAt(open);
+    const body = source.slice(open + 1, close);
+    const edits = [{ from: open, to: open + 1, text: '`' }];
+    for (let index = 0; index < body.length; index++) {
+        const at = open + 1 + index;
+        if (body[index] === '\\') {
+            if (body[index + 1] === quote) {
+                edits.push({ from: at, to: at + 1, text: '' });
+            }
+            index++;
+        }
+        else if (body[index] === '`') {
+            edits.push({ from: at, to: at + 1, text: '\\`' });
+        }
+    }
+    edits.push({ from: close, to: close + 1, text: '`' });
+    return edits;
+}

package/dist/unwrap.d.ts

@@ -0,0 +1,10 @@
+import type { OffsetRange } from './document.ts';
+import type { EditSource } from './edit-source.ts';
+import type { TextEdit } from './types.ts';
+export type UnwrapKind = 'if' | 'else' | 'removeElse' | 'for' | 'while' | 'do' | 'try' | 'removeCatch' | 'removeFinally' | 'braces';
+export interface UnwrapTarget {
+    readonly kind: UnwrapKind;
+    readonly range: OffsetRange;
+    readonly edits: readonly TextEdit[];
+}
+export declare function unwrapTargets(source: EditSource, offset: number, language: string, indentUnit: string): UnwrapTarget[];

package/dist/unwrap.js

@@ -0,0 +1,320 @@
+import { isPhp, isScript, isWordCharacter } from './lexical.js';
+import { whitespaceOf } from './line-text.js';
+import { enclosingBraces } from './statements.js';
+import { placeAt } from './text-places.js';
+import { skipTriviaBack } from './trivia.js';
+const SCAN_LIMIT = 2_000_000;
+const LOOPS = new Set(['for', 'foreach']);
+function wordBefore(source, end) {
+    const to = skipTriviaBack(source, end);
+    let from = to;
+    while (from > 0 && isWordCharacter(source.charAt(from - 1))) {
+        from--;
+    }
+    return from === to ? null : { text: source.slice(from, to), from };
+}
+function skipSpaces(source, at) {
+    let next = at;
+    while (/\s/u.test(source.charAt(next))) {
+        next++;
+    }
+    return next;
+}
+function wordAt(source, at) {
+    let end = at;
+    while (end < at + 12 && isWordCharacter(source.charAt(end))) {
+        end++;
+    }
+    return source.slice(at, end);
+}
+/* The closer of the bracket at `open`. */
+function closerOf(source, open) {
+    const closer = source.charAt(open) === '(' ? ')' : '}';
+    const text = source.slice(open + 1, Math.min(source.line(source.lineCount - 1).end, open + 1 + SCAN_LIMIT));
+    for (let index = text.indexOf(closer); index >= 0; index = text.indexOf(closer, index + 1)) {
+        const context = source.context(open + 1 + index);
+        if (context.mode === 'code' && context.bracket?.at === open) {
+            return open + 1 + index;
+        }
+    }
+    return null;
+}
+/* The header of the block that opens at `open`, or null for a function, a class, an object and the like. */
+function headerOf(source, open) {
+    const before = skipTriviaBack(source, open);
+    const last = source.charAt(before - 1);
+    if (last === ')') {
+        const paren = source.context(before - 1).bracket;
+        // The lexer flags the parenthesis of `foreach` and `elseif` as plain, so the word decides.
+        const keyword = paren === undefined ? null : wordBefore(source, paren.at);
+        if (keyword === null) {
+            return null;
+        }
+        if (LOOPS.has(keyword.text) || keyword.text === 'await') {
+            const loop = keyword.text === 'await' ? wordBefore(source, keyword.from) : keyword;
+            return loop !== null && LOOPS.has(loop.text) ? { word: 'for', start: loop.from } : null;
+        }
+        if (keyword.text === 'elseif') {
+            return { word: 'if', start: keyword.from, elseStart: keyword.from };
+        }
+        if (keyword.text === 'if') {
+            const before = wordBefore(source, keyword.from);
+            return { word: 'if', start: keyword.from, elseStart: before?.text === 'else' ? before.from : undefined };
+        }
+        if (keyword.text === 'while') {
+            return { word: 'while', start: keyword.from };
+        }
+        return keyword.text === 'catch' ? { word: 'catch', start: keyword.from } : null;
+    }
+    const word = wordBefore(source, open);
+    if (word !== null) {
+        return word.text === 'else' || word.text === 'try' || word.text === 'finally' || word.text === 'do' || word.text === 'catch'
+            ? { word: word.text, start: word.from }
+            : null;
+    }
+    // The lexer takes a brace after `;` or `{` for an object, so only the text before it says that it is a block.
+    const inBlock = last === ';' || last === '{' || before === 0 || (last === '}' && source.context(before - 1).bracket?.block === true);
+    return inBlock ? { word: 'braces', start: open } : null;
+}
+/* The block that ends right before `end`, past whitespace and comments. */
+function blockEndingAt(source, end) {
+    const close = skipTriviaBack(source, end) - 1;
+    const open = close >= 0 && source.charAt(close) === '}' ? source.context(close).bracket : undefined;
+    if (open === undefined || open.template === true) {
+        return null;
+    }
+    const header = headerOf(source, open.at);
+    return header === null ? null : { header, open: open.at, close };
+}
+/* The closer of the block after an optional parenthesis, starting at `at`. */
+function blockAfter(source, at, parenthesis) {
+    let next = skipSpaces(source, at);
+    if (parenthesis) {
+        const close = source.charAt(next) === '(' ? closerOf(source, next) : null;
+        if (close === null) {
+            return null;
+        }
+        next = skipSpaces(source, close + 1);
+    }
+    return source.charAt(next) === '{' ? closerOf(source, next) : null;
+}
+/* The end of an `if` statement whose first block closes at `close`, past its `else if` and `else` clauses. */
+function ifEnd(source, close) {
+    let end = close + 1;
+    for (;;) {
+        const at = skipSpaces(source, end);
+        const word = wordAt(source, at);
+        let next = null;
+        if (word === 'elseif') {
+            next = blockAfter(source, at + word.length, true);
+        }
+        else if (word === 'else') {
+            const after = skipSpaces(source, at + word.length);
+            next = wordAt(source, after) === 'if' ? blockAfter(source, after + 2, true) : blockAfter(source, at + word.length, false);
+        }
+        if (next === null) {
+            return end;
+        }
+        end = next + 1;
+    }
+}
+/* The `try` block that closes at `close` and the `catch` and `finally` blocks behind it. */
+function tryClauses(source, close) {
+    const clauses = [{ word: 'try', close }];
+    for (;;) {
+        const at = skipSpaces(source, clauses.at(-1).close + 1);
+        const word = wordAt(source, at);
+        if (word !== 'catch' && word !== 'finally') {
+            return clauses;
+        }
+        const closer = blockAfter(source, at + word.length, source.charAt(skipSpaces(source, at + word.length)) === '(');
+        if (closer === null) {
+            return clauses;
+        }
+        clauses.push({ word, close: closer });
+    }
+}
+/* The end of a `do` statement whose block closes at `close`, with its `while` condition. */
+function doEnd(source, close) {
+    const at = skipSpaces(source, close + 1);
+    if (wordAt(source, at) !== 'while') {
+        return close + 1;
+    }
+    const paren = skipSpaces(source, at + 5);
+    const closer = source.charAt(paren) === '(' ? closerOf(source, paren) : null;
+    if (closer === null) {
+        return close + 1;
+    }
+    return closer + 1 + (/^[ \t]*;/.exec(source.slice(closer + 1, closer + 16))?.[0].length ?? 0);
+}
+function lineBreakLength(source, at) {
+    const char = source.charAt(at);
+    if (char === '\r') {
+        return source.charAt(at + 1) === '\n' ? 2 : 1;
+    }
+    return char === '\n' ? 1 : 0;
+}
+/* The construct and the line it leaves blank, as one deletion. */
+function deleteConstruct(source, start, end) {
+    const first = source.line(source.lineAt(start));
+    const last = source.line(source.lineAt(end));
+    return {
+        from: source.slice(first.start, start).trim() === '' ? first.start : start,
+        to: source.slice(end, last.end).trim() === '' ? last.next : end,
+        text: ''
+    };
+}
+/* The edits that keep the body of the block at `open` and drop the rest of the construct that runs from `start` to `end`. */
+function unwrapEdits(source, indentUnit, start, open, close, end) {
+    if (source.slice(open + 1, close).trim() === '') {
+        return [deleteConstruct(source, start, end)];
+    }
+    let afterOpen = open + 1;
+    while (source.charAt(afterOpen) === ' ' || source.charAt(afterOpen) === '\t') {
+        afterOpen++;
+    }
+    const headerLine = source.line(source.lineAt(start));
+    const headerIndent = whitespaceOf(headerLine.text).length;
+    // The body takes the place of the header, so the header's own indentation goes too.
+    const edits = [
+        { from: source.slice(headerLine.start, start).trim() === '' ? headerLine.start : start, to: afterOpen + lineBreakLength(source, afterOpen), text: '' }
+    ];
+    let delta = 0;
+    for (let index = source.lineAt(open) + 1; index < source.lineAt(close); index++) {
+        const line = source.line(index);
+        if (line.text.trim() === '') {
+            continue;
+        }
+        const indent = whitespaceOf(line.text).length;
+        if (delta === 0) {
+            delta = indent > headerIndent ? indent - headerIndent : indentUnit.length;
+        }
+        const removed = Math.min(delta, indent);
+        if (removed > 0) {
+            edits.push({ from: line.start, to: line.start + removed, text: '' });
+        }
+    }
+    const closing = source.line(source.lineAt(close));
+    const alone = source.slice(closing.start, close).trim() === '';
+    let from = close;
+    if (alone && closing.start > 0) {
+        from = source.line(source.lineAt(close) - 1).end;
+    }
+    else {
+        while (from > closing.start && /[ \t]/.test(source.charAt(from - 1))) {
+            from--;
+        }
+    }
+    edits.push({ from, to: end, text: '' });
+    return edits;
+}
+/* The `if` statement an `else` block belongs to, and the block right before the `else`. */
+function ifOf(source, header) {
+    let current = header;
+    let first = null;
+    for (;;) {
+        const previous = blockEndingAt(source, current.elseStart ?? current.start);
+        if (previous === null || previous.header.word !== 'if') {
+            return null;
+        }
+        first ??= previous;
+        if (previous.header.elseStart === undefined) {
+            return { start: previous.header.start, previous: first };
+        }
+        current = previous.header;
+    }
+}
+/* The `try` block and its clauses around a `catch` or `finally` block. */
+function tryOf(source, header) {
+    let current = header;
+    for (;;) {
+        const previous = blockEndingAt(source, current.start);
+        if (previous === null || (previous.header.word !== 'try' && previous.header.word !== 'catch')) {
+            return null;
+        }
+        if (previous.header.word === 'try') {
+            return { start: previous.header.start, clauses: tryClauses(source, previous.close) };
+        }
+        current = previous.header;
+    }
+}
+function targetsOf(source, header, open, indentUnit) {
+    const close = closerOf(source, open);
+    if (close === null) {
+        return [];
+    }
+    switch (header.word) {
+        case 'if': {
+            const end = ifEnd(source, close);
+            return [{ kind: 'if', range: { from: header.start, to: end }, edits: unwrapEdits(source, indentUnit, header.start, open, close, end) }];
+        }
+        case 'else': {
+            const chain = ifOf(source, header);
+            if (chain === null) {
+                return [];
+            }
+            const range = { from: chain.start, to: close + 1 };
+            return [
+                { kind: 'else', range, edits: unwrapEdits(source, indentUnit, chain.start, open, close, close + 1) },
+                { kind: 'removeElse', range, edits: [{ from: chain.previous.close + 1, to: close + 1, text: '' }] }
+            ];
+        }
+        case 'for':
+        case 'while':
+            return [
+                {
+                    kind: header.word,
+                    range: { from: header.start, to: close + 1 },
+                    edits: unwrapEdits(source, indentUnit, header.start, open, close, close + 1)
+                }
+            ];
+        case 'do': {
+            const end = doEnd(source, close);
+            return [{ kind: 'do', range: { from: header.start, to: end }, edits: unwrapEdits(source, indentUnit, header.start, open, close, end) }];
+        }
+        case 'try': {
+            const end = tryClauses(source, close).at(-1).close + 1;
+            return [{ kind: 'try', range: { from: header.start, to: end }, edits: unwrapEdits(source, indentUnit, header.start, open, close, end) }];
+        }
+        case 'catch':
+        case 'finally': {
+            const statement = tryOf(source, header);
+            const index = statement?.clauses.findIndex((clause) => clause.close === close) ?? -1;
+            if (statement === null || index < 1) {
+                return [];
+            }
+            const others = statement.clauses.filter((clause, position) => position !== index && clause.word !== 'try');
+            // A try needs a catch or a finally, so the last of them stays, and a finally needs a catch beside it.
+            if (header.word === 'catch' ? others.length === 0 : !others.some((clause) => clause.word === 'catch')) {
+                return [];
+            }
+            return [
+                {
+                    kind: header.word === 'catch' ? 'removeCatch' : 'removeFinally',
+                    range: { from: statement.start, to: statement.clauses.at(-1).close + 1 },
+                    edits: [{ from: statement.clauses[index - 1].close + 1, to: close + 1, text: '' }]
+                }
+            ];
+        }
+        default:
+            return [{ kind: 'braces', range: { from: open, to: close + 1 }, edits: unwrapEdits(source, indentUnit, open, open, close, close + 1) }];
+    }
+}
+/*
+ * What can be unwrapped or removed around an offset, innermost first: a statement whose body stays and whose header goes,
+ * or a clause that goes with its body. Only the blocks of control statements and bare blocks count, not functions, classes or objects.
+ */
+export function unwrapTargets(source, offset, language, indentUnit) {
+    const place = placeAt(source, offset, language);
+    if (place.kind !== 'code' || !(isScript(place.language) || isPhp(place.language))) {
+        return [];
+    }
+    const targets = [];
+    for (const open of enclosingBraces(source, offset)) {
+        const header = headerOf(source, open);
+        if (header !== null) {
+            targets.push(...targetsOf(source, header, open, indentUnit));
+        }
+    }
+    return targets;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.43.0",
+  "version": "0.44.1",
   "type": "module",
   "exports": {
     ".": {