@adecore/editor-core 0.39.0 → 0.40.1

package/dist/block-folds.js

@@ -46,8 +46,11 @@ function markdownFolds(lineCount, getLine) {
     }
     flushTable(lineCount - 1);
     for (const [index, heading] of headings.entries()) {
-        const next = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level);
-        let end = (next?.line ?? lineCount) - 1;
+        let next = index + 1;
+        while (next < headings.length && headings[next].level > heading.level) {
+            next++;
+        }
+        let end = (headings[next]?.line ?? lineCount) - 1;
         while (end > heading.line && getLine(end).text.trim() === '') {
             end--;
         }

package/dist/bracket-tracker.js

@@ -1,4 +1,5 @@
-import { bracketRules, initialBracketState, lexBrackets, sameBracketState } from './brackets.js';
+import { initialBracketState, lexBrackets, sameBracketState } from './brackets.js';
+import { lexerRules } from './lexical.js';
 /* How much text one stretch between checkpoints holds, which is what an edit makes the tracker lex again. */
 const STRETCH_LENGTH = 4096;
 const IGNORE = {
@@ -16,7 +17,7 @@ export class BracketTracker {
     text;
     stretchLength;
     language = '';
-    rules = bracketRules('');
+    rules = lexerRules('');
     checkpoints = [];
     /* The first stale checkpoint: what comes before it is proven, and so is its state. */
     proven = 0;
@@ -107,7 +108,7 @@ export class BracketTracker {
             return;
         }
         this.language = language;
-        this.rules = bracketRules(language);
+        this.rules = lexerRules(language);
         this.checkpoints = [{ line: 0, state: initialBracketState(), low: 0, stale: true }];
         this.proven = 0;
     }

package/dist/brackets.d.ts

@@ -1,3 +1,4 @@
+import { type LexerRules } from './lexical.ts';
 export interface BracketIndex {
     pairs: ReadonlyMap<number, number>;
     unmatched: ReadonlySet<number>;
@@ -18,23 +19,12 @@ export interface BracketState {
     expression: boolean;
     stack: OpenBracket | undefined;
 }
-export interface BracketRules {
-    script: boolean;
-    hash: boolean;
-    hashAtWordStart: boolean;
-    dash: boolean;
-    phpAttributes: boolean;
-    slash: boolean;
-    block: boolean;
-    markup: boolean;
-}
 export interface BracketVisitor {
     open(at: number, depth: number): void;
     close(at: number, depth: number): void;
     mismatch(at: number): void;
 }
 export declare function initialBracketState(): BracketState;
-export declare function bracketRules(language: string): BracketRules;
 export declare function sameBracketState(left: BracketState, right: BracketState): boolean;
-export declare function lexBrackets(state: BracketState, rules: BracketRules, text: string, from: number, to: number, offset: number, visitor: BracketVisitor): void;
+export declare function lexBrackets(state: BracketState, rules: LexerRules, text: string, from: number, to: number, offset: number, visitor: BracketVisitor): void;
 export declare function scanBrackets(text: string, language?: string): BracketIndex;

package/dist/brackets.js

@@ -1,19 +1,7 @@
-import { hasBlockComments, hasDashComments, hasHashComments, hashNeedsWordStart, hasMarkupComments, hasSlashComments, isPhp, isScript, isWordCharacter, openers, startsExpressionAfter, startsExpressionAt, startsWord } from './lexical.js';
+import { isWordCharacter, lexerRules, openers, startsExpressionAfter, startsExpressionAt, startsWord } from './lexical.js';
 export function initialBracketState() {
     return { mode: 'code', quote: '', inClass: false, expression: true, stack: undefined };
 }
-export function bracketRules(language) {
-    return {
-        script: isScript(language),
-        hash: hasHashComments(language),
-        hashAtWordStart: hashNeedsWordStart(language),
-        dash: hasDashComments(language),
-        phpAttributes: isPhp(language),
-        slash: hasSlashComments(language),
-        block: hasBlockComments(language),
-        markup: hasMarkupComments(language)
-    };
-}
 export function sameBracketState(left, right) {
     if (left.mode !== right.mode || left.quote !== right.quote || left.inClass !== right.inClass || left.expression !== right.expression) {
         return false;
@@ -121,7 +109,7 @@ export function lexBrackets(state, rules, text, from, to, offset, visitor) {
         }
         else if ((rules.slash && char === '/' && next === '/') ||
             (rules.dash && char === '-' && next === '-') ||
-            (rules.hash && char === '#' && !(rules.phpAttributes && next === '[') && (!rules.hashAtWordStart || startsWord(text, at)))) {
+            (rules.hash && char === '#' && !(rules.php && next === '[') && (!rules.hashAtWordStart || startsWord(text, at)))) {
             state.mode = 'line-comment';
         }
         else if (rules.block && char === '/' && next === '*') {
@@ -179,7 +167,7 @@ export function scanBrackets(text, language = 'typescript') {
     const pairs = new Map();
     const unmatched = new Set();
     let open = [];
-    lexBrackets(initialBracketState(), bracketRules(language), text, 0, text.length, 0, {
+    lexBrackets(initialBracketState(), lexerRules(language), text, 0, text.length, 0, {
         open(at) {
             open.push(at);
         },

package/dist/closer-tracker.js

@@ -12,7 +12,6 @@ export class CloserTracker {
             this.marks.shift();
         }
     }
-    /* The closer that sits at `offset`, which a Tab there steps over. */
     isCloserAt(offset) {
         return this.marks.some((mark) => mark.close === offset);
     }

package/dist/doc-comments.js

@@ -53,7 +53,6 @@ export function findDocComments(text, language, limit = MAX_DOC_COMMENTS) {
         if (range.kind !== 'comment' || commentRole((from, to) => text.slice(from, to), range.from, range.to) === undefined) {
             continue;
         }
-        // Three stars or more is a banner, not a comment about the code under it.
         if (text[range.from + 3] === '*' || bodies.some(([from, to]) => range.from >= from && range.from < to)) {
             continue;
         }

package/dist/document.d.ts

@@ -131,6 +131,8 @@ export declare class DocumentModel {
     private deleteRanges;
     private applySelectionEdits;
     private newlineAt;
+    private lineOf;
+    private boundsOf;
     private escaped;
     private typingContext;
     private isInterpolation;

package/dist/document.js

@@ -38,7 +38,7 @@ function sameSelections(left, right) {
     return left.length === right.length && left.every((selection, index) => selection.anchor === right[index].anchor && selection.head === right[index].head);
 }
 function trailingBlankLength(text) {
-    return text.match(/[\t ]*$/)?.[0].length ?? 0;
+    return /[\t ]*$/.exec(text)[0].length;
 }
 function changesText(rope, edit) {
     return edit.text.length !== edit.to - edit.from || rope.slice(edit.from, edit.to) !== edit.text;
@@ -789,10 +789,10 @@ export class DocumentModel {
             return null;
         }
         const wrapped = surround(selected, text);
-        const reversed = selection.anchor > selection.head;
-        const start = 1;
         const end = 1 + wrapped.inner.length;
-        return { from, to, text: wrapped.text, anchor: reversed ? end : start, head: reversed ? start : end };
+        return selection.anchor > selection.head
+            ? { from, to, text: wrapped.text, anchor: end, head: 1 }
+            : { from, to, text: wrapped.text, anchor: 1, head: end };
     }
     /* A closer alone on its line goes back to the indentation of the line its opener is on. */
     dedentCloser(offset, closer, opener) {
@@ -802,7 +802,7 @@ export class DocumentModel {
         if (!/^[\t ]*$/.test(before)) {
             return null;
         }
-        const indent = whitespaceOf(this.getLine(this.rope.lineAt(opener)).text);
+        const indent = whitespaceOf(this.lineOf(opener).text);
         if (indent === before) {
             return null;
         }
@@ -848,16 +848,14 @@ export class DocumentModel {
             return false;
         }
         const text = this.getText();
-        const scanned = scanBrackets(text.slice(0, offset) + opener + text.slice(offset), language);
-        return scanned.pairs.has(offset);
+        return scanBrackets(text.slice(0, offset) + opener + text.slice(offset), language).pairs.has(offset);
     }
     /*
      * Whether the text before `offset` ends in something a member is read from: a variable, the name of a
      * property or method after `->` or `?->`, or a `)` or `]`.
      */
     endsOperand(offset) {
-        const line = this.rope.lineBounds(this.rope.lineAt(offset));
-        const before = this.slice(line.start, offset);
+        const before = this.slice(this.boundsOf(offset).start, offset);
         if (/[)\]]$/.test(before)) {
             return true;
         }
@@ -919,9 +917,8 @@ export class DocumentModel {
             return { from: offset, to: offset, text, anchor: text.length, head: text.length };
         }), { source: 'command' });
     }
-    /* The visual column of an offset, with tabs going to the next tab stop. */
     columnOf(offset, tabSize) {
-        return indentationColumn(this.slice(this.rope.lineBounds(this.rope.lineAt(offset)).start, offset), tabSize);
+        return indentationColumn(this.slice(this.boundsOf(offset).start, offset), tabSize);
     }
     moveToLineEdge(command, tabSize, visualLine) {
         const home = command.endsWith('Home');
@@ -943,12 +940,12 @@ export class DocumentModel {
      * text to the first character, and from the first character or inside the indentation to the start.
      */
     homeOffset(offset, tabSize, visualLine) {
-        const line = this.getLine(this.rope.lineAt(offset));
+        const line = this.lineOf(offset);
         const row = visualLine?.(offset) ?? line;
+        const indent = this.firstNonSpace(line);
         if (row.start > line.start) {
-            return offset > row.start ? row.start : Math.max(this.firstNonSpace(line), line.start);
+            return offset > row.start ? row.start : Math.max(indent, line.start);
         }
-        const indent = this.firstNonSpace(line);
         if (offset === line.start) {
             return this.offsetAtColumn(line, this.smartIndentColumn(line.start, tabSize), tabSize);
         }
@@ -985,12 +982,9 @@ export class DocumentModel {
      * the way, and a stop at the end of the text sends the next one past them.
      */
     endOffset(offset, visualLine) {
-        const line = this.getLine(this.rope.lineAt(offset));
+        const line = this.lineOf(offset);
         const row = visualLine?.(offset) ?? line;
-        let end = row.end;
-        if (offset === row.end && offset < this.rope.length) {
-            end = line.end;
-        }
+        const end = offset === row.end && offset < this.rope.length ? line.end : row.end;
         let target = end;
         for (let at = end - 1; at >= line.start; at--) {
             if (at > line.start && visualLine !== undefined && visualLine(at).start === at) {
@@ -1168,7 +1162,7 @@ export class DocumentModel {
             if (command === 'indent') {
                 return { from: line.start, to: line.start, text: indentation };
             }
-            const length = line.text.startsWith('\t') ? 1 : Math.min(line.text.match(/^ */)?.[0].length ?? 0, tabSize);
+            const length = line.text.startsWith('\t') ? 1 : Math.min(/^ */.exec(line.text)[0].length, tabSize);
             return { from: line.start, to: line.start + length, text: '' };
         });
         return this.applyEdits(edits, { source: 'command' });
@@ -1346,10 +1340,10 @@ export class DocumentModel {
         const plan = (reach) => this.selections.map((selection) => {
             const { from, to } = rangeOf(selection);
             if (mode === 'below') {
-                const end = this.rope.lineBounds(this.rope.lineAt(selection.head)).end;
+                const end = this.boundsOf(selection.head).end;
                 return planEnter(source, end, end, { ...options, reach });
             }
-            const before = this.slice(this.rope.lineBounds(this.rope.lineAt(from)).start, from);
+            const before = this.slice(this.boundsOf(from).start, from);
             if (mode === 'split' && /^[\t ]*$/.test(before)) {
                 const start = from - before.length;
                 return { from: start, to: start, text: before + this.newlineAt(this.rope.lineAt(from)), caret: before.length };
@@ -1423,7 +1417,7 @@ export class DocumentModel {
             return true;
         }
         const closer = index.pairs.get(offset);
-        const indentAt = (at) => whitespaceOf(this.getLine(this.rope.lineAt(at)).text).length;
+        const indentAt = (at) => whitespaceOf(this.lineOf(at).text).length;
         if (closer === undefined || indentAt(closer) >= indentAt(offset)) {
             return false;
         }
@@ -1545,10 +1539,11 @@ export class DocumentModel {
     }
     /* Backspace inside the indentation of a line goes back to the previous tab stop, and at the start of a line joins it with the one above. */
     backspaceStart(offset, tabSize) {
-        const line = this.rope.lineBounds(this.rope.lineAt(offset));
+        const index = this.rope.lineAt(offset);
+        const line = this.rope.lineBounds(index);
         if (offset === line.start && line.start > 0) {
             // Joining with the line above also takes the whitespace that trails it.
-            const previous = this.getLine(this.rope.lineAt(offset) - 1);
+            const previous = this.getLine(index - 1);
             return previous.end - trailingBlankLength(previous.text);
         }
         const prefix = this.slice(line.start, offset);
@@ -1585,7 +1580,13 @@ export class DocumentModel {
         const first = this.rope.lineBounds(0);
         return first.next > first.end ? this.slice(first.end, first.next) : '\n';
     }
-    /* Whether the character at `offset` is preceded by an odd number of backslashes. */
+    lineOf(offset) {
+        return this.rope.getLine(this.rope.lineAt(offset));
+    }
+    boundsOf(offset) {
+        return this.rope.lineBounds(this.rope.lineAt(offset));
+    }
+    /* Preceded by an odd number of backslashes. */
     escaped(offset) {
         let count = 0;
         while (offset > 0 && this.rope.charAt(--offset) === '\\') {
@@ -1613,7 +1614,7 @@ export class DocumentModel {
         if (this.rope.charAt(from) === ';') {
             return from;
         }
-        const line = this.getLine(this.rope.lineAt(from));
+        const line = this.lineOf(from);
         const prefix = this.slice(line.start, from).trimEnd();
         if (!prefix || /[([,=:+\-*/%&|!?]$/.test(prefix)) {
             return undefined;
@@ -1662,7 +1663,7 @@ export class DocumentModel {
         if (word !== null) {
             return word;
         }
-        const line = this.getLine(this.rope.lineAt(at));
+        const line = this.lineOf(at);
         return line.start === line.end ? { from: 0, to: length } : { from: line.start, to: line.end };
     }
     /* The identifier, or its camel hump, that an offset is in or at the end of; null when it is on something else. */
@@ -1778,13 +1779,12 @@ export class DocumentModel {
     expandSelectionTo(ranges) {
         return this.expandSelection(ranges);
     }
-    /* The range when it holds the stretch and is larger than it, else null. */
     largerRange(range, from, to) {
         return range !== null && range.from <= from && range.to >= to && (range.from < from || range.to > to) ? range : null;
     }
     lexicalExpansion(selection, from, to) {
-        const first = this.getLine(this.rope.lineAt(from));
-        const last = this.getLine(this.rope.lineAt(to));
+        const first = this.lineOf(from);
+        const last = this.lineOf(to);
         const candidates = [
             this.wordRange(selection.head),
             { from: first.start, to: last.end },
@@ -1823,7 +1823,6 @@ export class DocumentModel {
         this.occurrenceSession = { wholeWord, notFound, signature: this.occurrenceSignature() };
         this.occurrencesExhausted = notFound;
     }
-    /* Whether a range touches a selection that is already there. */
     overlapsSelection(from, to) {
         return this.selections.some((selection) => {
             const range = rangeOf(selection);
@@ -1867,9 +1866,8 @@ export class DocumentModel {
     }
     /* Takes the newest caret away, or the selection when there is one caret. */
     unselectOccurrence() {
-        const changed = this.selections.length > 1
-            ? this.changeSelections(this.selections.slice(0, -1))
-            : this.changeSelections([{ anchor: this.selections[0].head, head: this.selections[0].head }]);
+        const head = this.selections[0].head;
+        const changed = this.changeSelections(this.selections.length > 1 ? this.selections.slice(0, -1) : [{ anchor: head, head }]);
         this.occurrenceSession = undefined;
         this.occurrencesExhausted = false;
         return changed;

package/dist/edit-regions.js

@@ -1,4 +1,5 @@
 import { vueRegionAt } from './languages.js';
+import { textStart } from './line-text.js';
 import { hasJsx, jsxChildren } from './markup-regions.js';
 const SCAN_LIMIT = 2_000_000;
 export function phpLiteralAt(source, offset) {
@@ -10,8 +11,7 @@ export function phpTagAt(source, offset) {
     return context.mode === 'html' && (context.markup === 'tag' || context.markup === 'equals' || context.markup === 'value');
 }
 function firstContent(source, line) {
-    const bounds = source.line(line);
-    return bounds.start + bounds.text.length - bounds.text.trimStart().length;
+    return textStart(source.line(line));
 }
 function mixedPhpLine(source, line) {
     const bounds = source.line(line);
@@ -22,8 +22,7 @@ function mixedPhpLine(source, line) {
             return true;
         }
         const at = bounds.start + match.index;
-        const context = source.context(at);
-        const { mode, embedded } = context;
+        const { mode, embedded } = source.context(at);
         if (match[0] === '?>') {
             if (mode !== 'html' && embedded === undefined) {
                 return true;

package/dist/enter.d.ts

@@ -13,5 +13,7 @@ export interface EnterPlan {
     text: string;
     caret: number;
 }
+export declare const caseLabel: RegExp;
 export declare function continues(text: string, context: TypingContext, language: string): boolean;
+export declare function lineContinues(source: EditSource, language: string, index: number): boolean;
 export declare function planEnter(source: EditSource, from: number, to: number, options: EnterOptions): EnterPlan;

package/dist/enter.js

@@ -13,6 +13,7 @@ const markupLanguages = /^(html|xml|svg|vue|svelte|astro|mdx|jsx|tsx|javascriptr
 const voidElements = /^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/i;
 const trailingOperator = /(?:=>|&&|\|\||\?\?|[=*%?|&]|(?<!\+)\+|(?<!-)-)$/;
 const lookBack = 50;
+export const caseLabel = /^(?:case\b[^]*|default)\s*:$/;
 /* 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. */
@@ -24,7 +25,7 @@ function escapeForPattern(text) {
     return text.replace(/[.*+?^${}()|[\]\\/-]/g, '\\$&');
 }
 /*
- * Whether the code before `end` leaves its statement open: after the parenthesis of a braceless
+ * Whether the code in `text` 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) {
@@ -40,6 +41,11 @@ export function continues(text, context, language) {
     }
     return trailingOperator.test(text);
 }
+export function lineContinues(source, language, index) {
+    const line = source.line(index);
+    const text = line.text.trimEnd();
+    return text.length > 0 && continues(text, source.context(line.start + text.length), language);
+}
 class Enter {
     source;
     options;
@@ -50,11 +56,9 @@ class Enter {
     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) {
+            const leading = whitespaceOf(source.slice(source.line(index).start, from));
+            const newline = source.newline(index);
             return { from, to, text: newline + leading, caret: newline.length + leading.length };
         }
         const context = source.context(from);
@@ -92,9 +96,7 @@ class Enter {
         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);
+        return lineContinues(this.source, this.options.language, index);
     }
     inCode(from, to, lineContext, index) {
         const { source, options } = this;
@@ -193,7 +195,7 @@ class Enter {
             return /(?::|[|>][+-]?)$/.test(trimmed) && !trimmed.trimStart().startsWith('#');
         }
         if (isBraced(language)) {
-            return (context.bracket === undefined || context.bracket.close === '}') && /^(?:case\b[^]*|default)\s*:$/.test(trimmed.trimStart());
+            return (context.bracket === undefined || context.bracket.close === '}') && caseLabel.test(trimmed.trimStart());
         }
         return false;
     }

package/dist/fold-roles.js

@@ -1,5 +1,5 @@
-import { isImportLine, rangeOf, textStart } from './lexical-folds.js';
-import { isBlank } from './line-text.js';
+import { isImportLine, rangeOf } from './lexical-folds.js';
+import { isBlank, textStart } from './line-text.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;

package/dist/lexical-folds.d.ts

@@ -6,6 +6,5 @@ export interface LexicalFoldOptions {
     regions?: boolean;
     lineComments?: boolean;
 }
-export declare function textStart(line: DocumentLine): number;
 export declare function rangeOf(startLine: number, endLine: number, getLine: (line: number) => DocumentLine, kind: FoldingRange['kind'], role?: FoldRole): FoldingRange;
 export declare function lexicalFolds(lineCount: number, getLine: (line: number) => DocumentLine, language: string, options?: LexicalFoldOptions): FoldingRange[];

package/dist/lexical-folds.js

@@ -1,4 +1,5 @@
 import { commentSyntax } from './languages.js';
+import { textStart } from './line-text.js';
 /* 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();
 function register(languages, words) {
@@ -30,10 +31,6 @@ function bracketDelta(text) {
     }
     return depth;
 }
-/* The offset of the first character of a line that is not indentation. */
-export function textStart(line) {
-    return line.start + (line.text.length - line.text.trimStart().length);
-}
 /* A fold of whole lines, from the end of the first to the end of the last. */
 export function rangeOf(startLine, endLine, getLine, kind, role) {
     return {

package/dist/lexical.d.ts

@@ -1,13 +1,19 @@
 export declare const openers: Readonly<Record<string, string>>;
 export declare function startsWord(text: string, at: number): boolean;
+export interface LexerRules {
+    script: boolean;
+    php: boolean;
+    hash: boolean;
+    hashAtWordStart: boolean;
+    dash: boolean;
+    slash: boolean;
+    block: boolean;
+    markup: boolean;
+}
+export declare function lexerRules(language: string): LexerRules;
 export declare function isScript(language: string): boolean;
 export declare function isPhp(language: string): boolean;
 export declare function hasHashComments(language: string): boolean;
-export declare function hashNeedsWordStart(language: string): boolean;
-export declare function hasDashComments(language: string): boolean;
-export declare function hasBlockComments(language: string): boolean;
-export declare function hasSlashComments(language: string): boolean;
-export declare function hasMarkupComments(language: string): boolean;
 export declare function isBraced(language: string): boolean;
 export declare function indentsByBrackets(language: string): boolean;
 export declare function hasSmartSemicolon(language: string): boolean;

package/dist/lexical.js

@@ -28,6 +28,19 @@ register('lua haskell hs', { dash: true });
 function rulesOf(language) {
     return languageRules.get(language.toLowerCase()) ?? NO_RULES;
 }
+export function lexerRules(language) {
+    const rules = rulesOf(language);
+    return {
+        script: isScript(language),
+        php: isPhp(language),
+        hash: hasHashComments(language),
+        hashAtWordStart: rules.hash === 'boundary',
+        dash: rules.dash,
+        slash: rules.slash,
+        block: rules.block,
+        markup: rules.markup
+    };
+}
 export function isScript(language) {
     return /^(typescript|javascript|typescriptreact|javascriptreact|tsx|jsx|ts|js|vue)$/i.test(language);
 }
@@ -37,23 +50,6 @@ export function isPhp(language) {
 export function hasHashComments(language) {
     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) {
-    return rulesOf(language).hash === 'boundary';
-}
-export function hasDashComments(language) {
-    return rulesOf(language).dash;
-}
-export function hasBlockComments(language) {
-    return rulesOf(language).block;
-}
-export function hasSlashComments(language) {
-    return rulesOf(language).slash;
-}
-export function hasMarkupComments(language) {
-    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) {
     return rulesOf(language).braced;
 }

package/dist/line-commands.js

@@ -1,5 +1,5 @@
 import { commentSyntax } from './languages.js';
-import { continues } from './enter.js';
+import { caseLabel, lineContinues } from './enter.js';
 import { indentsByBrackets } from './lexical.js';
 import { isBlank, rangeOf, whitespaceOf } from './line-text.js';
 import { markupGuard } from './markup-regions.js';
@@ -172,17 +172,15 @@ export function planToggleCase(source, selections) {
     const result = [];
     let delta = 0;
     for (const [index, target] of targets.entries()) {
-        const context = source.context(target.from);
-        const inString = context.mode === 'quote' || context.mode === 'template';
-        const converted = convertCase(texts[index], lower, inString);
+        const { mode } = source.context(target.from);
+        const converted = convertCase(texts[index], lower, mode === 'quote' || mode === 'template');
         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 });
+        const end = start + converted.length;
+        result.push(target.word || selection.anchor <= selection.head ? { anchor: start, head: end } : { anchor: end, head: start });
         delta += converted.length - texts[index].length;
     }
     if (targets.every((target) => target.from === target.to)) {
@@ -198,7 +196,6 @@ function frames(context) {
     }
     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
@@ -251,22 +248,17 @@ function targetIndent(source, options, line, context, indentOf) {
         }
     }
     const previous = previousCodeLine(source, line);
-    if (previous !== null && source.context(source.line(previous).start).bracket === context.bracket && lineContinues(source, options, previous)) {
+    if (previous !== null && source.context(source.line(previous).start).bracket === context.bracket && lineContinues(source, options.language, previous)) {
         return isContinuation(source, options, previous) ? indentOf(previous) : indentOf(previous) + options.unit;
     }
     return base;
 }
-function lineContinues(source, options, line) {
-    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, options, line) {
     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));
+        lineContinues(source, options.language, previous));
 }
 function previousCodeLine(source, line) {
     for (let candidate = line - 1; candidate >= 0; candidate--) {

package/dist/line-text.d.ts

@@ -1,5 +1,7 @@
+import type { DocumentLine } from './rope.ts';
 import type { Selection } from './types.ts';
 export declare function whitespaceOf(text: string): string;
+export declare function textStart(line: DocumentLine): number;
 export declare function isBlank(text: string): boolean;
 export declare function indentText(width: number, options: {
     tabSize: number;

package/dist/line-text.js

@@ -2,6 +2,10 @@
 export function whitespaceOf(text) {
     return /^[\t ]*/.exec(text)[0];
 }
+/* The offset of the first character of a line that is not indentation. */
+export function textStart(line) {
+    return line.start + (line.text.length - line.text.trimStart().length);
+}
 export function isBlank(text) {
     return text.trim() === '';
 }

package/dist/markup-regions.js

@@ -1,3 +1,4 @@
+import { whitespaceOf } from './line-text.js';
 const JSX_LANGUAGES = /^(typescriptreact|javascriptreact|tsx|jsx|javascript|js|mjs|cjs)$/i;
 const NAME = /[\w$.:-]/;
 const START_OF_NAME = /[A-Za-z_$>]/;
@@ -352,7 +353,6 @@ export function jsxChildren(text) {
     scanner.scan();
     return (offset) => insideAny(scanner.children, offset);
 }
-/* Whether a language is one whose scripts can hold JSX. */
 export function hasJsx(language) {
     return JSX_LANGUAGES.test(language);
 }
@@ -379,8 +379,7 @@ export function markupGuard(source, language) {
         const ranges = jsxRanges(source.slice(0, source.line(source.lineCount - 1).end));
         return (line) => {
             const bounds = source.line(line);
-            const start = bounds.start + (/^[\t ]*/.exec(bounds.text)?.[0].length ?? 0);
-            return insideAny(ranges, start);
+            return insideAny(ranges, bounds.start + whitespaceOf(bounds.text).length);
         };
     }
     return () => false;