@adecore/editor-core 0.21.1 → 0.22.0

package/dist/block-folds.js

@@ -11,16 +11,9 @@ const HEREDOC = /<<<[ \t]*(["']?)([A-Za-z_]\w*)\1\s*$/;
 function markdownFolds(lineCount, getLine) {
     const result = [];
     const headings = [];
-    let first = 0;
-    if (lineCount > 0 && getLine(0).text.trim() === '---') {
-        for (let line = 1; line < lineCount; line++) {
-            const text = getLine(line).text.trim();
-            if (text === '---' || text === '...') {
-                result.push(rangeOf(0, line, getLine, 'block', 'front-matter'));
-                first = line + 1;
-                break;
-            }
-        }
+    const frontMatter = frontMatterEnd(lineCount, getLine);
+    if (frontMatter !== -1) {
+        result.push(rangeOf(0, frontMatter, getLine, 'block', 'front-matter'));
     }
     let tableStart = -1;
     const flushTable = (end) => {
@@ -29,19 +22,12 @@ function markdownFolds(lineCount, getLine) {
         }
         tableStart = -1;
     };
-    for (let line = first; line < lineCount; line++) {
+    for (let line = frontMatter + 1; line < lineCount; line++) {
         const text = getLine(line).text;
         const fence = FENCE.exec(text);
         if (fence !== null) {
             flushTable(line - 1);
-            const marker = fence[1];
-            let end = -1;
-            for (let next = line + 1; next < lineCount && end === -1; next++) {
-                const closer = FENCE.exec(getLine(next).text);
-                if (closer !== null && closer[1][0] === marker[0] && closer[1].length >= marker.length && getLine(next).text.trim() === closer[1]) {
-                    end = next;
-                }
-            }
+            const end = fenceEnd(line, fence[1], lineCount, getLine);
             if (end !== -1) {
                 result.push(rangeOf(line, end, getLine, 'block', 'code-fence'));
                 line = end;
@@ -71,6 +57,29 @@ function markdownFolds(lineCount, getLine) {
     }
     return result;
 }
+/* The line that closes front matter opened on the first line, or -1. */
+function frontMatterEnd(lineCount, getLine) {
+    if (lineCount === 0 || getLine(0).text.trim() !== '---') {
+        return -1;
+    }
+    for (let line = 1; line < lineCount; line++) {
+        const text = getLine(line).text.trim();
+        if (text === '---' || text === '...') {
+            return line;
+        }
+    }
+    return -1;
+}
+/* The line that closes a fence opened on `line` with `marker`, or -1. */
+function fenceEnd(line, marker, lineCount, getLine) {
+    for (let next = line + 1; next < lineCount; next++) {
+        const closer = FENCE.exec(getLine(next).text)?.[1];
+        if (closer !== undefined && closer[0] === marker[0] && closer.length >= marker.length && getLine(next).text.trim() === closer) {
+            return next;
+        }
+    }
+    return -1;
+}
 /* `<?php ... ?>` blocks that sit between markup, and heredocs and nowdocs. A block that opens the file is the file, not a fold. */
 function phpFolds(lineCount, getLine) {
     const result = [];

package/dist/closer-tracker.js

@@ -1,4 +1,4 @@
-const limit = 64;
+const maxMarks = 64;
 /*
  * The closers the editor inserted by itself and the caret has not left yet, which Tab steps over. A
  * mark follows its opener and closer through edits and goes as soon as an edit replaces either one
@@ -8,7 +8,7 @@ export class CloserTracker {
     marks = [];
     add(open, close) {
         this.marks.push({ open, close });
-        if (this.marks.length > limit) {
+        if (this.marks.length > maxMarks) {
             this.marks.shift();
         }
     }

package/dist/comments.js

@@ -1,19 +1,11 @@
 import { commentSyntax } from './languages.js';
+import { indentText, isBlank, rangeOf, whitespaceOf } from './line-text.js';
 import { mapOffset } from './offsets.js';
 import { indentationColumn } from './structure.js';
-function whitespaceOf(text) {
-    return /^[\t ]*/.exec(text)[0];
-}
-function isBlank(text) {
-    return text.trim() === '';
-}
 function syntaxOf(source, options, line) {
     const syntax = commentSyntax(options.language, source.region(line));
     return options.lineToken === undefined ? syntax : { ...syntax, line: options.lineToken };
 }
-function rangeOf(selection) {
-    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
-}
 /* The runs of adjacent lines the selections touch. A selection that ends at the start of a line does not touch it. */
 function blocksOf(source, selections, span) {
     const blocks = [];
@@ -50,12 +42,6 @@ function isCommented(text, syntax, multiline) {
     }
     return trimmed.length >= block.open.length + block.close.length && trimmed.startsWith(block.open) && trimmed.endsWith(block.close);
 }
-function indentText(width, options) {
-    if (options.insertSpaces) {
-        return ' '.repeat(width);
-    }
-    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
-}
 /* The new place of a line after the edits, which never cross a line break. */
 function geometryOf(source, edits, index) {
     const bounds = source.line(index);
@@ -128,14 +114,19 @@ export function planLineComments(source, selections, options) {
     }
     return { edits, selections: finalSelections(source, selections, blocks, edits, allCommented, placed, lineBased, options.lineSpan) };
 }
-function minimumIndent(source, block, syntax, options) {
+/* The indentation of the least indented non-blank line, infinite when every line is blank. */
+function smallestIndent(source, first, last, tabSize) {
     let minimum = Number.POSITIVE_INFINITY;
-    for (let line = block.first; line <= block.last; line++) {
+    for (let line = first; line <= last; line++) {
         const text = source.line(line).text;
         if (!isBlank(text)) {
-            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), options.tabSize));
+            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), tabSize));
         }
     }
+    return minimum;
+}
+function minimumIndent(source, block, syntax, options) {
+    let minimum = smallestIndent(source, block.first, block.last, options.tabSize);
     if (block.first > 0) {
         const previous = source.line(block.first - 1).text;
         const marker = syntax.line ?? syntax.block?.open;
@@ -327,13 +318,7 @@ function wrapRange(source, from, to, block, options) {
             { from: to, to, text: ` ${block.close}` }
         ];
     }
-    let minimum = Number.POSITIVE_INFINITY;
-    for (let line = first; line <= last; line++) {
-        const text = source.line(line).text;
-        if (!isBlank(text)) {
-            minimum = Math.min(minimum, indentationColumn(whitespaceOf(text), options.tabSize));
-        }
-    }
+    const minimum = smallestIndent(source, first, last, options.tabSize);
     const space = indentText(Number.isFinite(minimum) ? minimum : 0, options);
     const newline = source.newline(first);
     const closing = source.charAt(to - 1) === '\n' ? `${space}${block.close}${newline}` : `${newline}${space}${block.close}`;

package/dist/document.d.ts

@@ -103,6 +103,7 @@ export declare class DocumentModel {
     private changeLineIndentation;
     private toggleComment;
     private selectedLines;
+    private touchedLines;
     private duplicate;
     private deleteLines;
     private moveLines;

package/dist/document.js

@@ -8,6 +8,7 @@ import { isPlainText, vueRegionAt } from './languages.js';
 import { blockFolds } from './block-folds.js';
 import { applyFoldHints, markFileHeader } from './fold-roles.js';
 import { lexicalFolds } from './lexical-folds.js';
+import { rangeOf, whitespaceOf } from './line-text.js';
 import { isQuote, replacesComparison, surround, swapQuotes } from './typing-handlers.js';
 import { scanBrackets } from './brackets.js';
 import { hasSmartSemicolon, isPhp } from './lexical.js';
@@ -31,15 +32,9 @@ const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
 const arrowContinues = /^[\p{L}_{]/u;
 const wordCommand = /^(select|delete)?(word|camel)(Left|Right)$/i;
 const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
-function rangeOf(selection) {
-    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
-}
 function sameSelections(left, right) {
     return left.length === right.length && left.every((selection, index) => selection.anchor === right[index].anchor && selection.head === right[index].head);
 }
-function indentLength(text) {
-    return text.match(/^[\t ]*/)?.[0].length ?? 0;
-}
 function trailingBlankLength(text) {
     return text.match(/[\t ]*$/)?.[0].length ?? 0;
 }
@@ -141,6 +136,7 @@ function inverseChanges(changes) {
 function range(first, last) {
     return Array.from({ length: last - first + 1 }, (_, index) => first + index);
 }
+/* Runs of consecutive line numbers, from a sorted list. */
 function blocks(indices) {
     const result = [];
     for (const index of indices) {
@@ -172,7 +168,8 @@ function indentStopLength(prefix, tabSize) {
 }
 function positionIn(rope, offset) {
     const line = rope.lineAt(offset);
-    return { line, column: Math.min(offset, rope.lineBounds(line).end) - rope.lineBounds(line).start };
+    const bounds = rope.lineBounds(line);
+    return { line, column: Math.min(offset, bounds.end) - bounds.start };
 }
 /* Simultaneous edits of `rope` as a sequence, last to first, so each edit's position in `rope` is also its position once the ones after it are applied. */
 function editsOf(rope, edits) {
@@ -207,6 +204,14 @@ function stretchEdits(before, after, transactions) {
     }
     return [{ start: positionIn(before, prefix), end: positionIn(before, oldEnd), text: after.slice(prefix, newEnd) }];
 }
+/* An occurrence selected with its caret `shift` characters into it, as the caret stood in the selection it repeats. */
+function occurrenceSelection(match, shift) {
+    if (shift === 0) {
+        return { anchor: match.to, head: match.from };
+    }
+    const caret = Math.min(match.from + shift, match.to);
+    return { anchor: caret === match.to ? match.from : match.to, head: caret };
+}
 /*
  * Text with a selection, undo history and the editing commands of a code editor, and no idea how it
  * is drawn. Offsets are UTF-16 code units, lines and columns zero-based. The text is a persistent
@@ -391,10 +396,7 @@ export class DocumentModel {
         return true;
     }
     positionAt(offset) {
-        const clamped = offsetIn(this.rope, offset);
-        const line = this.rope.lineAt(clamped);
-        const bounds = this.rope.lineBounds(line);
-        return { line, column: Math.min(clamped, bounds.end) - bounds.start };
+        return positionIn(this.rope, offsetIn(this.rope, offset));
     }
     /* A column past the end of its line lands on the end of the line, before the line break. */
     offsetAt(position) {
@@ -727,7 +729,7 @@ export class DocumentModel {
         if (!/^[\t ]*$/.test(before)) {
             return null;
         }
-        const indent = this.getLine(this.rope.lineAt(opener)).text.match(/^[\t ]*/)?.[0] ?? '';
+        const indent = whitespaceOf(this.getLine(this.rope.lineAt(opener)).text);
         if (indent === before) {
             return null;
         }
@@ -1094,16 +1096,11 @@ export class DocumentModel {
             : planBlockComment(source, this.selections, commentOptions);
         return plan !== null && this.applyEdits(plan.edits, { source: 'command', selections: plan.selections });
     }
-    /* The lines the carets and selections touch. A selection that ends at the start of a line does not touch it. */
+    /* The lines the carets and selections touch, sorted. */
     selectedLines(span) {
         const indices = new Set();
         for (const selection of this.selections) {
-            const { from, to } = rangeOf(selection);
-            let first = this.rope.lineAt(from);
-            let last = this.rope.lineAt(to);
-            if (to > from && this.rope.lineBounds(last).start === to) {
-                last--;
-            }
+            let { first, last } = this.touchedLines(selection);
             if (span) {
                 first = span(first).first;
                 last = Math.max(last, span(last).last);
@@ -1114,6 +1111,13 @@ export class DocumentModel {
         }
         return [...indices].sort((left, right) => left - right);
     }
+    /* The lines a selection touches; one that ends at the start of a line does not touch it. */
+    touchedLines(selection) {
+        const { from, to } = rangeOf(selection);
+        const first = this.rope.lineAt(from);
+        const last = this.rope.lineAt(to);
+        return { first, last: last > first && this.rope.lineBounds(last).start === to ? last - 1 : last };
+    }
     /* A selection is copied in place, its copy selected; a caret duplicates its line and moves down with it. */
     duplicate(span) {
         const carets = this.selections.filter((selection) => selection.anchor === selection.head);
@@ -1281,7 +1285,7 @@ export class DocumentModel {
             const index = this.rope.lineAt(selection.head);
             const line = this.rope.lineBounds(index);
             const text = this.getLine(index).text;
-            const indent = (text.match(/^[\t ]*/)?.[0] ?? '') + (/^[\t ]*[)\]}]/.test(text) ? unit : '');
+            const indent = whitespaceOf(text) + (/^[\t ]*[)\]}]/.test(text) ? unit : '');
             return { from: line.start, to: line.start, text: indent + this.newlineAt(index), anchor: indent.length, head: indent.length };
         }), { source: 'command' });
     }
@@ -1333,7 +1337,7 @@ export class DocumentModel {
             return true;
         }
         const closer = index.pairs.get(offset);
-        const indentAt = (at) => this.getLine(this.rope.lineAt(at)).text.match(/^[\t ]*/)[0].length;
+        const indentAt = (at) => whitespaceOf(this.getLine(this.rope.lineAt(at)).text).length;
         if (closer === undefined || indentAt(closer) >= indentAt(offset)) {
             return false;
         }
@@ -1665,7 +1669,7 @@ export class DocumentModel {
             { from: 0, to: this.rope.length }
         ];
         if (first.start === last.start) {
-            candidates.push({ from: first.start + indentLength(first.text), to: first.end - trailingBlankLength(first.text) });
+            candidates.push({ from: first.start + whitespaceOf(first.text).length, to: first.end - trailingBlankLength(first.text) });
         }
         for (const range of this.structure()) {
             candidates.push({ from: range.innerFrom, to: range.innerTo }, range);
@@ -1734,10 +1738,7 @@ export class DocumentModel {
             this.rememberOccurrence(wholeWord, notFoundBefore);
             return false;
         }
-        const shift = primary.head - from;
-        const caret = Math.min(match.from + shift, match.to);
-        const added = shift === 0 ? { anchor: match.to, head: match.from } : { anchor: caret === match.to ? match.from : match.to, head: caret };
-        const changed = this.changeSelections([...this.selections, added]);
+        const changed = this.changeSelections([...this.selections, occurrenceSelection(match, primary.head - from)]);
         this.rememberOccurrence(wholeWord, false);
         return changed;
     }
@@ -1769,10 +1770,7 @@ export class DocumentModel {
         if (matches.length === 0) {
             return false;
         }
-        const changed = this.changeSelections(matches.map((match) => {
-            const caret = Math.min(match.from + shift, match.to);
-            return shift === 0 ? { anchor: match.to, head: match.from } : { anchor: caret === match.to ? match.from : match.to, head: caret };
-        }));
+        const changed = this.changeSelections(matches.map((match) => occurrenceSelection(match, shift)));
         this.rememberOccurrence(wholeWord, false);
         return changed;
     }
@@ -1781,12 +1779,7 @@ export class DocumentModel {
         const forward = this.selections.at(-1).head >= this.selections.at(-1).anchor;
         const carets = [];
         for (const selection of this.selections) {
-            const { from, to } = rangeOf(selection);
-            const first = this.rope.lineAt(from);
-            let last = this.rope.lineAt(to);
-            if (last > first && to === this.rope.lineBounds(last).start) {
-                last--;
-            }
+            const { first, last } = this.touchedLines(selection);
             for (let line = first; line <= last; line++) {
                 const end = this.rope.lineBounds(line).end;
                 carets.push({ anchor: end, head: end });

package/dist/enter.js

@@ -1,8 +1,8 @@
 import { commentSyntax } from './languages.js';
-import { hasHashComments, isBraced, isPhp } from './lexical.js';
+import { hasHashComments, isBraced, isPhp, openers } from './lexical.js';
+import { whitespaceOf } from './line-text.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, '+');
@@ -16,10 +16,7 @@ const lookBack = 50;
 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) {
+function isIndentOnly(text) {
     return /^[\t ]*$/.test(text);
 }
 function escapeForPattern(text) {
@@ -59,15 +56,20 @@ class Enter {
             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);
+        return this.inLiteral(from, to, context, index) ?? this.inCode(from, to, context, index);
+    }
+    /* The plan inside a comment or a string, or null where Enter acts as in code. */
+    inLiteral(from, to, context, index) {
+        if (context.mode === 'block-comment') {
+            return this.inBlockComment(from, to, context, index);
+        }
+        if (from !== to) {
+            return null;
+        }
+        if (context.mode === 'line-comment') {
+            return this.inLineComment(from, context, index);
+        }
+        return context.mode === 'quote' ? this.inString(from, context, index) : null;
     }
     /* 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) {
@@ -81,7 +83,7 @@ class Enter {
     }
     previousCodeLine(index) {
         for (let candidate = index - 1; candidate >= 0 && candidate >= index - lookBack; candidate--) {
-            if (!isBlank(this.source.line(candidate).text)) {
+            if (!isIndentOnly(this.source.line(candidate).text)) {
                 return candidate;
             }
         }
@@ -101,7 +103,7 @@ class Enter {
         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 trailing = commentAt !== undefined && commentAt >= line.start && !isIndentOnly(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) ?? '';
@@ -114,10 +116,10 @@ class Enter {
         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;
+        const opener = openers[last] !== undefined && context.bracket?.close === openers[last] && context.bracket.at === line.start + trimmed.length - 1;
         if (opener) {
             const inner = start + unit;
-            if (next === closers[last]) {
+            if (next === openers[last]) {
                 return { from, to: afterWhitespace, text: newline + inner + newline + start, caret: newline.length + inner.length };
             }
             const closing = last === '{' && source.unclosedBrace(context.bracket.at) ? this.closeBrace(from, afterWhitespace, line, rest, newline, start, inner) : null;
@@ -135,7 +137,8 @@ class Enter {
             return plain(this.blockIndent(line.text, start) + unit);
         }
         if (continues(trimmed, context, language)) {
-            const continued = this.previousCodeLine(index) !== null && this.lineContinues(this.previousCodeLine(index));
+            const previous = this.previousCodeLine(index);
+            const continued = previous !== null && this.lineContinues(previous);
             return plain(continued ? leading : start + unit);
         }
         return plain(start);
@@ -215,7 +218,7 @@ class Enter {
             return { from, to: textStart, text: newline + leading, caret: newline.length + leading.length };
         }
         const code = source.slice(line.start, commentStart);
-        const onlyComment = isBlank(code);
+        const onlyComment = isIndentOnly(code);
         let spacing = ' ';
         if (onlyComment) {
             const gap = whitespaceOf(source.slice(commentStart + marker.length, line.end));
@@ -344,7 +347,11 @@ class Enter {
             }
             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))) {
+        if (isDoc &&
+            onOpener &&
+            source.lineAt(closeAt) === index &&
+            isIndentOnly(source.slice(to, closeAt)) &&
+            isIndentOnly(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 };

package/dist/fold-roles.js

@@ -1,4 +1,5 @@
-import { isImportLine } from './lexical-folds.js';
+import { isImportLine, rangeOf, textStart } from './lexical-folds.js';
+import { isBlank } 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;
@@ -40,9 +41,6 @@ export function bracketRole(slice, from, language) {
     // 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.
@@ -58,8 +56,7 @@ export function markFileHeader(ranges, getLine, lineCount, language) {
             return;
         }
     }
-    const start = getLine(candidate.startLine);
-    if (candidate.from > start.start + (start.text.length - start.text.trimStart().length)) {
+    if (candidate.from > textStart(getLine(candidate.startLine))) {
         return;
     }
     const next = candidate.endLine + 1 < lineCount ? getLine(candidate.endLine + 1).text : '';
@@ -109,19 +106,9 @@ export function applyFoldHints(ranges, hints, lineAt, getLine, slice, minimum) {
         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 }),
-            ...edgesOf(hint)
-        });
+        const role = serverRole(hint.kind, getLine(startLine).text.trimStart());
+        result.push({ ...rangeOf(startLine, endLine, getLine, 'server', role), ...edgesOf(hint) });
     }
     return result.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
 }

package/dist/lexical-folds.d.ts

@@ -6,5 +6,6 @@ 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

@@ -30,13 +30,16 @@ 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) {
-    const start = getLine(startLine);
     return {
         startLine,
         endLine,
-        from: start.start + (start.text.length - start.text.trimStart().length),
+        from: textStart(getLine(startLine)),
         to: getLine(endLine).end,
         kind,
         ...(role === undefined ? {} : { role })

package/dist/line-commands.js

@@ -1,18 +1,10 @@
 import { commentSyntax } from './languages.js';
 import { continues } from './enter.js';
 import { indentsByBrackets } from './lexical.js';
+import { isBlank, rangeOf, whitespaceOf } from './line-text.js';
 import { markupGuard } from './markup-regions.js';
 import { mapOffset } from './offsets.js';
 const identifier = /[\p{L}\p{N}\p{M}\p{Pc}$]/u;
-function rangeOf(selection) {
-    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
-}
-function whitespaceOf(text) {
-    return /^[\t ]*/.exec(text)[0];
-}
-function isBlank(text) {
-    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, edits) {
     return edits.filter((edit) => edit.from < offset).reduce((sum, edit) => sum + edit.text.length - (Math.min(edit.to, offset) - edit.from), 0);
@@ -106,7 +98,7 @@ export function planJoinLines(source, selections, options) {
                 !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) {
+            if (converts) {
                 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: '/*' });

package/dist/line-text.d.ts

@@ -0,0 +1,11 @@
+import type { Selection } from './types.ts';
+export declare function whitespaceOf(text: string): string;
+export declare function isBlank(text: string): boolean;
+export declare function indentText(width: number, options: {
+    tabSize: number;
+    insertSpaces: boolean;
+}): string;
+export declare function rangeOf(selection: Selection): {
+    from: number;
+    to: number;
+};

package/dist/line-text.js

@@ -0,0 +1,17 @@
+/* The spaces and tabs a line starts with. */
+export function whitespaceOf(text) {
+    return /^[\t ]*/.exec(text)[0];
+}
+export function isBlank(text) {
+    return text.trim() === '';
+}
+/* Indentation `width` columns wide, in tabs as far as they reach when spaces are off. */
+export function indentText(width, options) {
+    if (options.insertSpaces) {
+        return ' '.repeat(width);
+    }
+    return '\t'.repeat(Math.floor(width / options.tabSize)) + ' '.repeat(width % options.tabSize);
+}
+export function rangeOf(selection) {
+    return { from: Math.min(selection.anchor, selection.head), to: Math.max(selection.anchor, selection.head) };
+}