@adecore/editor-core 0.39.0 → 0.40.1

package/dist/paste.js

@@ -1,4 +1,4 @@
-import { indentText, isBlank, whitespaceOf } from './line-text.js';
+import { indentText, isBlank, rangeOf, whitespaceOf } from './line-text.js';
 import { mapOffset } from './offsets.js';
 import { indentationColumn } from './structure.js';
 /* A line break at the end is the end of the last line, not a line of its own. */
@@ -63,12 +63,7 @@ function reindent(source, from, text, options) {
  * the line it lands on, when it lands in code and not in a string, a comment or a heredoc.
  */
 export function planPaste(source, selections, text, options) {
-    const ordered = selections.map((selection, index) => ({
-        from: Math.min(selection.anchor, selection.head),
-        to: Math.max(selection.anchor, selection.head),
-        index
-    }));
-    ordered.sort((left, right) => left.from - right.from);
+    const ordered = selections.map((selection, index) => ({ ...rangeOf(selection), index })).sort((left, right) => left.from - right.from);
     const segments = perCaretLines(text, selections.length);
     const newline = text.includes('\r\n') ? '\r\n' : '\n';
     const edits = [];

package/dist/structure.js

@@ -1,5 +1,6 @@
 import { bracketRole, commentRole } from './fold-roles.js';
 import { openers } from './lexical.js';
+import { whitespaceOf } from './line-text.js';
 /* Clamped to 1 through 16, with 4 for anything that is not a finite number. */
 export function tabWidth(options) {
     const requested = options.tabSize ?? 4;
@@ -69,7 +70,7 @@ function indentationFolds(lineCount, getLine, tabSize, minimum) {
         if (!text.trim()) {
             continue;
         }
-        const indent = indentationColumn(text.match(/^[\t ]*/)?.[0] ?? '', tabSize);
+        const indent = indentationColumn(whitespaceOf(text), tabSize);
         while (headers.length > 0 && indent <= headers.at(-1).indent) {
             close(headers.pop(), previous.line);
         }

package/dist/typing-context.js

@@ -1,4 +1,4 @@
-import { hasBlockComments, hasDashComments, hasHashComments, hashNeedsWordStart, hasMarkupComments, hasSlashComments, isPhp, isScript, isWordCharacter, openers, startsExpression, startsExpressionAfter, startsWord } from './lexical.js';
+import { isWordCharacter, lexerRules, openers, startsExpression, startsExpressionAfter, startsWord } from './lexical.js';
 import { scanPhpMarkup } from './php-markup.js';
 const PHP_HEREDOC = /^<<<[ \t]*(["']?)([A-Za-z_]\w*)\1[ \t]*$/;
 const PHP_OPEN = /<\?(?:php\b|=)/;
@@ -11,18 +11,6 @@ const blockWords = /^(else|try|finally|do)$/;
 function initial() {
     return { mode: 'code', escaped: false, inClass: false, expression: true, word: '' };
 }
-function rulesOf(language) {
-    return {
-        script: isScript(language),
-        php: isPhp(language),
-        hash: hasHashComments(language),
-        hashAtWordStart: hashNeedsWordStart(language),
-        dash: hasDashComments(language),
-        slash: hasSlashComments(language),
-        block: hasBlockComments(language),
-        markup: hasMarkupComments(language)
-    };
-}
 function scanComment(state, text, at, end) {
     const close = state.mode === 'block-comment' ? '*/' : '-->';
     if (at + close.length <= end && text.startsWith(close, at)) {
@@ -171,7 +159,9 @@ function stepScript(state, text, at, end, offset) {
     if (state.mode === 'block-comment') {
         return scanComment(state, text, at, end);
     }
-    return state.mode === 'code' ? scanCode(state, (scriptRules ??= rulesOf('javascript')), text, at, end, offset) : scanLiteral(state, text, at, end, offset);
+    return state.mode === 'code'
+        ? scanCode(state, (scriptRules ??= lexerRules('javascript')), text, at, end, offset)
+        : scanLiteral(state, text, at, end, offset);
 }
 const scriptLexer = { initial, step: stepScript };
 function normalizeLine(state, multilineQuotes) {
@@ -287,7 +277,7 @@ export class TypingContexts {
             this.language = id;
             this.states = [this.initialState(id)];
         }
-        const rules = rulesOf(id);
+        const rules = lexerRules(id);
         while (this.states.length <= line) {
             const previous = this.states.at(-1);
             const source = this.line(this.states.length - 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-core",
-  "version": "0.39.0",
+  "version": "0.40.1",
   "type": "module",
   "exports": {
     ".": {
@@ -16,7 +16,7 @@
     "test": "bun test --conditions=source"
   },
   "devDependencies": {
-    "@types/bun": "^1.4.2",
+    "@types/bun": "^1.4.4",
     "typescript": "^7.0.2"
   },
   "license": "FSL-1.1-MIT",

package/src/block-folds.ts

@@ -16,49 +16,71 @@ function markdownFolds(lineCount: number, getLine: (line: number) => DocumentLin
     const result: FoldingRange[] = [];
     const headings: { line: number; level: number }[] = [];
     const frontMatter = frontMatterEnd(lineCount, getLine);
+
     if (frontMatter !== -1) {
         result.push(rangeOf(0, frontMatter, getLine, 'block', 'front-matter'));
     }
+
     let tableStart = -1;
+
     const flushTable = (end: number): void => {
         if (tableStart !== -1 && end > tableStart) {
             result.push(rangeOf(tableStart, end, getLine, 'block', 'table'));
         }
+
         tableStart = -1;
     };
+
     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 end = fenceEnd(line, fence[1]!, lineCount, getLine);
+
             if (end !== -1) {
                 result.push(rangeOf(line, end, getLine, 'block', 'code-fence'));
                 line = end;
             }
+
             continue;
         }
+
         if (TABLE_ROW.test(text)) {
             tableStart = tableStart === -1 ? line : tableStart;
+
             continue;
         }
+
         flushTable(line - 1);
         const heading = HEADING.exec(text);
+
         if (heading !== null) {
             headings.push({ line, level: heading[1]!.length });
         }
     }
+
     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--;
         }
+
         if (end > heading.line) {
             result.push(rangeOf(heading.line, end, getLine, 'section'));
         }
     }
+
     return result;
 }
 
@@ -67,12 +89,15 @@ function frontMatterEnd(lineCount: number, getLine: (line: number) => DocumentLi
     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;
 }
 
@@ -80,10 +105,12 @@ function frontMatterEnd(lineCount: number, getLine: (line: number) => DocumentLi
 function fenceEnd(line: number, marker: string, lineCount: number, getLine: (line: number) => DocumentLine): number {
     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;
 }
 
@@ -91,31 +118,40 @@ function fenceEnd(line: number, marker: string, lineCount: number, getLine: (lin
 function phpFolds(lineCount: number, getLine: (line: number) => DocumentLine): FoldingRange[] {
     const result: FoldingRange[] = [];
     let open = -1;
+
     for (let line = 0; line < lineCount; line++) {
         const text = getLine(line).text;
         const heredoc = HEREDOC.exec(text);
+
         if (heredoc !== null) {
             const closer = new RegExp(`^\\s*${heredoc[2]}\\b`);
+
             for (let next = line + 1; next < lineCount; next++) {
                 if (closer.test(getLine(next).text)) {
                     result.push(rangeOf(line, next, getLine, 'block', 'heredoc'));
                     line = next;
+
                     break;
                 }
             }
+
             continue;
         }
+
         const opened = open === -1 ? text.search(/<\?(?:php\b|=)/) : -1;
         const closed = text.indexOf('?>', Math.max(0, opened));
+
         if (opened !== -1 && closed === -1) {
             open = line === 0 ? -1 : line;
         } else if (open !== -1 && closed !== -1) {
             if (line > open) {
                 result.push(rangeOf(open, line, getLine, 'block', 'php-tag'));
             }
+
             open = -1;
         }
     }
+
     return result;
 }
 
@@ -124,5 +160,6 @@ export function blockFolds(lineCount: number, getLine: (line: number) => Documen
     if (MARKDOWN.test(language)) {
         return markdownFolds(lineCount, getLine);
     }
+
     return language.toLowerCase() === 'php' ? phpFolds(lineCount, getLine) : [];
 }

package/src/bracket-tracker.ts

@@ -1,13 +1,5 @@
-import {
-    type BracketMatch,
-    type BracketRules,
-    type BracketState,
-    type BracketVisitor,
-    bracketRules,
-    initialBracketState,
-    lexBrackets,
-    sameBracketState
-} from './brackets.ts';
+import { type BracketMatch, type BracketState, type BracketVisitor, initialBracketState, lexBrackets, sameBracketState } from './brackets.ts';
+import { lexerRules, type LexerRules } from './lexical.ts';
 import type { TextRope } from './rope.ts';
 import type { DocumentChange } from './types.ts';
 
@@ -57,7 +49,7 @@ export class BracketTracker {
     private readonly text: () => BracketText;
     private readonly stretchLength: number;
     private language = '';
-    private rules: BracketRules = bracketRules('');
+    private rules: LexerRules = lexerRules('');
     private checkpoints: Checkpoint[] = [];
     /* The first stale checkpoint: what comes before it is proven, and so is its state. */
     private proven = 0;
@@ -74,8 +66,10 @@ export class BracketTracker {
         if (this.checkpoints.length === 0 || changes.length === 0) {
             return;
         }
+
         const edits: LineEdit[] = [];
         let delta = 0;
+
         for (const change of changes) {
             // The line above too, since an edit at the start of a line can turn the `\r` that ends it into a `\r\n`.
             const first = Math.max(0, before.lineAt(change.from) - 1);
@@ -83,6 +77,7 @@ export class BracketTracker {
             const newLast = after.lineAt(change.from + delta + change.insertedLength);
             delta += change.insertedLength - (change.to - change.from);
             const previous = edits.at(-1);
+
             if (previous !== undefined && first <= previous.oldLast) {
                 previous.oldLast = oldLast;
                 previous.newLast = newLast;
@@ -90,28 +85,37 @@ export class BracketTracker {
                 edits.push({ first, oldLast, newLast });
             }
         }
+
         const kept: Checkpoint[] = [];
         let index = 0;
         let shift = 0;
+
         for (const checkpoint of this.checkpoints) {
             let dropped = false;
+
             while (index < edits.length && checkpoint.line > edits[index]!.first) {
                 kept.at(-1)!.stale = true;
+
                 if (checkpoint.line <= edits[index]!.oldLast) {
                     dropped = true;
+
                     break;
                 }
+
                 shift = edits[index]!.newLast - edits[index]!.oldLast;
                 index++;
             }
+
             if (!dropped) {
                 checkpoint.line += shift;
                 kept.push(checkpoint);
             }
         }
+
         if (index < edits.length) {
             kept.at(-1)!.stale = true;
         }
+
         this.checkpoints = kept;
         this.proven = this.nextStale(0);
     }
@@ -122,27 +126,36 @@ export class BracketTracker {
      */
     match(offset: number, language: string, limit = Number.POSITIVE_INFINITY): BracketMatch | null | undefined {
         const rope = this.text();
+
         if (!/^[()[\]{}]$/.test(rope.charAt(offset))) {
             return undefined;
         }
+
         this.use(language);
         this.budget = limit;
         const line = rope.lineAt(offset);
+
         if (!this.prove(line)) {
             return null;
         }
+
         const index = this.stretchOf(line);
         const event = this.eventAt(index, offset);
+
         if (event === undefined) {
             return undefined;
         }
+
         if (event.kind === 'mismatch' || event.mate === null) {
             return { mate: undefined };
         }
+
         if (event.mate !== undefined) {
             return { mate: event.mate };
         }
+
         const mate = event.kind === 'open' ? this.closerAfter(index, event.depth) : this.openerBefore(index, event.depth);
+
         return mate === null ? null : { mate };
     }
 
@@ -150,17 +163,20 @@ export class BracketTracker {
         if (language === this.language && this.checkpoints.length > 0) {
             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;
     }
 
     private nextStale(from: number): number {
         let index = from;
+
         while (index < this.checkpoints.length && !this.checkpoints[index]!.stale) {
             index++;
         }
+
         return index;
     }
 
@@ -170,8 +186,10 @@ export class BracketTracker {
             if (this.budget <= 0) {
                 return false;
             }
+
             this.relex(this.proven, line);
         }
+
         return true;
     }
 
@@ -184,12 +202,14 @@ export class BracketTracker {
         const added: Checkpoint[] = [];
         let current = this.checkpoints[index]!;
         let line = current.line;
+
         for (;;) {
             const from = rope.lineBounds(line).start;
             const end = Math.min(stop, from + this.stretchLength >= rope.length ? rope.lineCount : Math.max(line + 1, rope.lineAt(from + this.stretchLength)));
             const to = end >= rope.lineCount ? rope.length : rope.lineBounds(end).start;
             let low = state.stack?.depth ?? 0;
             this.budget -= to - from;
+
             lexBrackets(state, this.rules, rope.slice(from, to), 0, to - from, from, {
                 open() {},
                 close(_at, depth) {
@@ -199,22 +219,28 @@ export class BracketTracker {
                     low = 0;
                 }
             });
+
             current.low = low;
             current.stale = false;
+
             if (end === stop) {
                 if (next !== undefined && !sameBracketState(state, next.state)) {
                     next.state = state;
                     next.stale = true;
                 }
+
                 break;
             }
+
             current = { line: end, state: { ...state }, low: 0, stale: true };
             added.push(current);
             line = end;
+
             if (end > until || this.budget <= 0) {
                 break;
             }
         }
+
         this.checkpoints.splice(index + 1, 0, ...added);
         this.proven = this.nextStale(index + 1);
     }
@@ -222,14 +248,17 @@ export class BracketTracker {
     private stretchOf(line: number): number {
         let low = 0;
         let high = this.checkpoints.length - 1;
+
         while (low < high) {
             const middle = Math.ceil((low + high) / 2);
+
             if (this.checkpoints[middle]!.line <= line) {
                 low = middle;
             } else {
                 high = middle - 1;
             }
         }
+
         return low;
     }
 
@@ -246,15 +275,18 @@ export class BracketTracker {
         let found: BracketEvent | undefined;
         // The openers this stretch opened; the ones from before it are only counted.
         let opened: number[] = [];
+
         this.lexStretch(index, {
             open(at, depth) {
                 opened.push(at);
+
                 if (at === offset) {
                     found = { kind: 'open', depth };
                 }
             },
             close(at, depth) {
                 const opener = opened.pop();
+
                 if (at === offset) {
                     found = { kind: 'close', depth, ...(opener === undefined ? {} : { mate: opener }) };
                 } else if (found?.kind === 'open' && found.mate === undefined && depth === found.depth) {
@@ -263,6 +295,7 @@ export class BracketTracker {
             },
             mismatch(at) {
                 opened = [];
+
                 if (at === offset) {
                     found = { kind: 'mismatch', depth: 0 };
                 } else if (found?.kind === 'open' && found.mate === undefined) {
@@ -270,6 +303,7 @@ export class BracketTracker {
                 }
             }
         });
+
         return found;
     }
 
@@ -279,10 +313,13 @@ export class BracketTracker {
             if (!this.prove(this.checkpoints[current]!.line)) {
                 return null;
             }
+
             if (this.checkpoints[current]!.low >= depth) {
                 continue;
             }
+
             let result: number | false | undefined;
+
             this.lexStretch(current, {
                 open() {},
                 close(at, closed) {
@@ -294,8 +331,10 @@ export class BracketTracker {
                     result ??= false;
                 }
             });
+
             return result === false ? undefined : result;
         }
+
         return undefined;
     }
 
@@ -305,7 +344,9 @@ export class BracketTracker {
             if (this.checkpoints[current]!.low >= depth) {
                 continue;
             }
+
             let result: number | undefined;
+
             this.lexStretch(current, {
                 ...IGNORE,
                 open(at, opened) {
@@ -314,8 +355,10 @@ export class BracketTracker {
                     }
                 }
             });
+
             return result;
         }
+
         return undefined;
     }
 }