@adecore/editor-core 0.38.0 → 0.40.0

package/src/markup-regions.ts

@@ -1,4 +1,5 @@
 import type { EditSource } from './edit-source.ts';
+import { whitespaceOf } from './line-text.ts';
 
 const JSX_LANGUAGES = /^(typescriptreact|javascriptreact|tsx|jsx|javascript|js|mjs|cjs)$/i;
 const NAME = /[\w$.:-]/;
@@ -39,93 +40,128 @@ class JsxScanner {
         let at = from;
         let previous = '';
         let word = '';
+
         while (at < text.length) {
             if (--this.budget < 0) {
                 return -1;
             }
+
             const char = text[at]!;
             const next = text[at + 1];
+
             if (/\s/.test(char)) {
                 at++;
+
                 continue;
             }
+
             if (char === '/' && next === '/') {
                 const end = text.indexOf('\n', at);
                 at = end < 0 ? text.length : end;
+
                 continue;
             }
+
             if (char === '/' && next === '*') {
                 const end = text.indexOf('*/', at + 2);
                 at = end < 0 ? text.length : end + 2;
+
                 continue;
             }
+
             if (char === '"' || char === "'") {
                 at = this.quoted(at);
                 previous = char;
                 word = '';
+
                 continue;
             }
+
             if (char === '`') {
                 at = this.template(at);
+
                 if (at < 0) {
                     return -1;
                 }
+
                 previous = char;
                 word = '';
+
                 continue;
             }
+
             const expressionStart = previous === '' || EXPRESSION_STARTS.includes(previous) || EXPRESSION_KEYWORDS.test(word);
+
             if (char === '/' && expressionStart) {
                 at = this.regex(at);
                 previous = '/';
                 word = '';
+
                 continue;
             }
+
             if (char === '<' && expressionStart && next !== undefined && START_OF_NAME.test(next)) {
                 const end = this.element(at, true);
+
                 if (end >= 0) {
                     at = end;
                     previous = ')';
                     word = '';
+
                     continue;
                 }
             }
+
             const closes = CLOSERS[char];
+
             if (closes !== undefined) {
                 const end = this.code(at + 1, closes);
+
                 if (end < 0) {
                     return -1;
                 }
+
                 at = end;
                 previous = closes;
                 word = '';
+
                 continue;
             }
+
             if (char === '}' || char === ')' || char === ']') {
                 if (closer === char) {
                     return at + 1;
                 }
+
                 if (closer !== null) {
                     return -1;
                 }
+
                 at++;
                 previous = char;
                 word = '';
+
                 continue;
             }
+
             if (/[\w$]/.test(char)) {
                 const start = at;
+
                 while (at < text.length && /[\w$]/.test(text[at]!)) {
                     at++;
                 }
+
                 word = text.slice(start, at);
                 previous = word.slice(-1);
+
                 continue;
             }
+
             previous = char;
             word = '';
             at++;
         }
+
         return closer === null ? text.length : -1;
     }
 
@@ -133,15 +169,18 @@ class JsxScanner {
         const { text } = this;
         const quote = text[from]!;
         let at = from + 1;
+
         while (at < text.length && text[at] !== quote && text[at] !== '\n') {
             at += text[at] === '\\' ? 2 : 1;
         }
+
         return Math.min(text.length, at + 1);
     }
 
     private template(from: number): number {
         const { text } = this;
         let at = from + 1;
+
         while (at < text.length) {
             if (text[at] === '\\') {
                 at += 2;
@@ -149,6 +188,7 @@ class JsxScanner {
                 return at + 1;
             } else if (text[at] === '$' && text[at + 1] === '{') {
                 at = this.code(at + 2, '}');
+
                 if (at < 0) {
                     return -1;
                 }
@@ -156,6 +196,7 @@ class JsxScanner {
                 at++;
             }
         }
+
         return text.length;
     }
 
@@ -163,8 +204,10 @@ class JsxScanner {
         const { text } = this;
         let at = from + 1;
         let inClass = false;
+
         while (at < text.length && text[at] !== '\n') {
             const char = text[at]!;
+
             if (char === '\\') {
                 at++;
             } else if (char === '[') {
@@ -174,8 +217,10 @@ class JsxScanner {
             } else if (char === '/' && !inClass) {
                 return at + 1;
             }
+
             at++;
         }
+
         return from + 1;
     }
 
@@ -186,15 +231,19 @@ class JsxScanner {
         this.depth++;
         const end = this.parseElement(from);
         this.depth--;
+
         if (end < 0) {
             this.children.length = children;
+
             if (previousEnd !== undefined) {
                 this.children[children - 1]!.to = previousEnd;
             }
         }
+
         if (end >= 0 && outermost && this.depth === 0) {
             this.ranges.push({ from, to: end });
         }
+
         return end;
     }
 
@@ -202,7 +251,9 @@ class JsxScanner {
         if (!this.collectChildren || from >= to) {
             return;
         }
+
         const previous = this.children.at(-1);
+
         if (previous !== undefined && previous.to === from) {
             previous.to = to;
         } else {
@@ -212,72 +263,100 @@ class JsxScanner {
 
     private skipSpace(from: number): number {
         let at = from;
+
         while (at < this.text.length && /\s/.test(this.text[at]!)) {
             at++;
         }
+
         return at;
     }
 
     private parseElement(from: number): number {
         const { text } = this;
         let at = from + 1;
+
         while (at < text.length && NAME.test(text[at]!)) {
             at++;
         }
+
         const name = text.slice(from + 1, at);
+
         for (;;) {
             at = this.skipSpace(at);
             const char = text[at];
+
             if (char === undefined || --this.budget < 0) {
                 return -1;
             }
+
             if (char === '/' && text[at + 1] === '/') {
                 const end = text.indexOf('\n', at + 2);
+
                 if (end < 0) {
                     return -1;
                 }
+
                 at = end + 1;
+
                 continue;
             }
+
             if (char === '/' && text[at + 1] === '*') {
                 const end = text.indexOf('*/', at + 2);
+
                 if (end < 0) {
                     return -1;
                 }
+
                 at = end + 2;
+
                 continue;
             }
+
             if (char === '/' && text[at + 1] === '>') {
                 return at + 2;
             }
+
             if (char === '>') {
                 at++;
+
                 break;
             }
+
             if (char === '{') {
                 at = this.code(at + 1, '}');
+
                 if (at < 0) {
                     return -1;
                 }
+
                 continue;
             }
+
             if (!/[A-Za-z_$]/.test(char)) {
                 return -1;
             }
+
             while (at < text.length && NAME.test(text[at]!)) {
                 at++;
             }
+
             at = this.skipSpace(at);
+
             if (text[at] !== '=') {
                 continue;
             }
+
             at = this.skipSpace(at + 1);
             const value = text[at];
+
             if (value === '"' || value === "'") {
                 const close = text.indexOf(value, at + 1);
+
                 if (close < 0) {
                     return -1;
                 }
+
                 this.values.push({ from: at, to: close + 1 });
                 at = close + 1;
             } else if (value === '{') {
@@ -287,34 +366,43 @@ class JsxScanner {
             } else {
                 return -1;
             }
+
             if (at < 0) {
                 return -1;
             }
         }
+
         for (;;) {
             const start = at;
+
             while (at < text.length && text[at] !== '<' && text[at] !== '{') {
                 at++;
             }
+
             this.child(start, text[at] === '<' ? at + 1 : at);
+
             if (at >= text.length || --this.budget < 0) {
                 return -1;
             }
+
             if (text[at] === '{') {
                 this.child(at, at + 1);
                 const from = at;
                 at = this.code(at + 1, '}');
+
                 if (at >= 0 && /^\{\s*\/\*/.test(text.slice(from, from + 20))) {
                     this.child(from + 1, at);
                 }
             } else if (text[at + 1] === '/') {
                 const closing = /^<\/\s*([\w$.:-]*)\s*>/.exec(text.slice(at, at + 200));
+
                 return closing !== null && closing[1] === name ? at + closing[0].length : -1;
             } else if (START_OF_NAME.test(text[at + 1] ?? '')) {
                 at = this.parseElement(at);
             } else {
                 return -1;
             }
+
             if (at < 0) {
                 return -1;
             }
@@ -326,6 +414,7 @@ class JsxScanner {
 export function jsxRanges(text: string): { from: number; to: number }[] {
     const scanner = new JsxScanner(text);
     scanner.scan();
+
     return scanner.ranges;
 }
 
@@ -333,9 +422,11 @@ export function jsxRanges(text: string): { from: number; to: number }[] {
 function insideAny(ranges: readonly { from: number; to: number }[], offset: number): boolean {
     let low = 0;
     let high = ranges.length - 1;
+
     while (low <= high) {
         const middle = (low + high) >> 1;
         const range = ranges[middle]!;
+
         if (offset < range.from) {
             high = middle - 1;
         } else if (offset >= range.to) {
@@ -344,6 +435,7 @@ function insideAny(ranges: readonly { from: number; to: number }[], offset: numb
             return true;
         }
     }
+
     return false;
 }
 
@@ -351,10 +443,10 @@ function insideAny(ranges: readonly { from: number; to: number }[], offset: numb
 export function jsxChildren(text: string): (offset: number) => boolean {
     const scanner = new JsxScanner(text, true);
     scanner.scan();
+
     return (offset) => insideAny(scanner.children, offset);
 }
 
-/* Whether a language is one whose scripts can hold JSX. */
 export function hasJsx(language: string): boolean {
     return JSX_LANGUAGES.test(language);
 }
@@ -363,6 +455,7 @@ export function hasJsx(language: string): boolean {
 export function isJsxAttributeValue(text: string, offset: number): boolean {
     const scanner = new JsxScanner(text);
     scanner.scan();
+
     return scanner.values.some((value) => value.from === offset);
 }
 
@@ -373,19 +466,24 @@ export function isJsxAttributeValue(text: string, offset: number): boolean {
  */
 export function markupGuard(source: EditSource, language: string): (line: number) => boolean {
     const id = language.toLowerCase();
+
     if (id === 'vue') {
         return (line) => {
             const region = source.region(line);
+
             return (region !== 'script' && region !== 'style') || /^\s*<\/?(?:script|style|template)\b/.test(source.line(line).text);
         };
     }
+
     if (hasJsx(id)) {
         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;
 }

package/src/offsets.ts

@@ -3,38 +3,48 @@ import type { TextEdit } from './types.ts';
 /* An offset after simultaneous edits. An edit that inserts at it leaves it in front of the new text when `stayBefore`. */
 export function mapOffset(offset: number, edits: readonly TextEdit[], stayBefore = false): number {
     let delta = 0;
+
     for (const edit of edits) {
         if (offset < edit.from || (stayBefore && offset === edit.from && edit.to === edit.from)) {
             break;
         }
+
         if (offset < edit.to) {
             return edit.from + delta + edit.text.length;
         }
+
         delta += edit.text.length - (edit.to - edit.from);
     }
+
     return offset + delta;
 }
 
 /* Reuse this index across selections while retaining both endpoint affinities. */
 export function offsetMapper(edits: readonly TextEdit[]): (offset: number, stayBefore?: boolean) => number {
     const deltas = new Float64Array(edits.length + 1);
+
     for (let index = 0; index < edits.length; index++) {
         const edit = edits[index]!;
         deltas[index + 1] = deltas[index]! + edit.text.length - (edit.to - edit.from);
     }
+
     return (offset, stayBefore = false) => {
         let low = 0,
             high = edits.length;
+
         while (low < high) {
             const middle = (low + high) >>> 1;
             const edit = edits[middle]!;
+
             if (edit.to < offset || (edit.to === offset && !(stayBefore && edit.from === edit.to))) {
                 low = middle + 1;
             } else {
                 high = middle;
             }
         }
+
         const edit = edits[low];
+
         return edit !== undefined && edit.from <= offset && offset < edit.to ? edit.from + deltas[low]! + edit.text.length : offset + deltas[low]!;
     };
 }

package/src/paste.ts

@@ -1,5 +1,5 @@
 import type { EditPlan, EditSource } from './edit-source.ts';
-import { indentText, isBlank, whitespaceOf } from './line-text.ts';
+import { indentText, isBlank, rangeOf, whitespaceOf } from './line-text.ts';
 import { mapOffset } from './offsets.ts';
 import { indentationColumn } from './structure.ts';
 import type { Selection, TextEdit } from './types.ts';
@@ -23,7 +23,9 @@ function perCaretLines(text: string, carets: number): string[] | null {
     if (carets < 2) {
         return null;
     }
+
     const lines = linesOf(text);
+
     return lines.length === carets ? lines : null;
 }
 
@@ -36,9 +38,11 @@ function perCaretLines(text: string, carets: number): string[] | null {
 function reindent(source: EditSource, from: number, text: string, options: PasteOptions): string {
     const newline = text.includes('\r\n') ? '\r\n' : '\n';
     const lines = text.split(/\r?\n/);
+
     if (lines.length < 2) {
         return text;
     }
+
     const line = source.line(source.lineAt(from));
     const before = source.slice(line.start, from);
     const caretColumn = indentationColumn(before, options.tabSize);
@@ -50,25 +54,32 @@ function reindent(source: EditSource, from: number, text: string, options: Paste
     const widths = lines.map((entry) => (isBlank(entry) ? null : indentationColumn(whitespaceOf(entry), options.tabSize)));
     const measured = widths.filter((width, index): width is number => width !== null && !(anchored && index === 0));
     const trailingBreak = isBlank(lines.at(-1)!);
+
     if (measured.length > 0) {
         // A reduce, not a spread: a paste of a few hundred thousand lines is more arguments than V8 takes in one call.
         const delta = target - measured.reduce((least, width) => Math.min(least, width));
+
         for (const [index, entry] of lines.entries()) {
             const width = widths[index];
+
             if (width === null || width === undefined || (anchored && index === 0)) {
                 continue;
             }
+
             // The first line follows the indentation already in front of the caret.
             const indent = Math.max(0, width + delta - (index === 0 ? caretColumn : 0));
+
             if (indent !== width) {
                 lines[index] = indentText(indent, options) + entry.slice(whitespaceOf(entry).length);
             }
         }
     }
+
     if (trailingBreak) {
         // What follows the paste stays under the indentation of the line it was on.
         lines[lines.length - 1] = whitespaceOf(before);
     }
+
     return lines.join(newline);
 }
 
@@ -78,29 +89,30 @@ function reindent(source: EditSource, from: number, text: string, options: Paste
  * the line it lands on, when it lands in code and not in a string, a comment or a heredoc.
  */
 export function planPaste(source: EditSource, selections: readonly Selection[], text: string, options: PasteOptions): EditPlan {
-    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: TextEdit[] = [];
+
     if (options.wholeLines && selections.every((selection) => selection.anchor === selection.head)) {
         const lineEdits = new Map<number, string>();
+
         for (const [position, { from }] of ordered.entries()) {
             const start = source.line(source.lineAt(from)).start;
             const piece = segments?.[position] ?? text;
             lineEdits.set(start, (lineEdits.get(start) ?? '') + (/\r?\n$/.test(piece) ? piece : piece + newline));
         }
+
         for (const [start, insert] of lineEdits) {
             edits.push({ from: start, to: start, text: insert });
         }
+
         return { edits, selections: selections.map((selection) => ({ anchor: mapOffset(selection.anchor, edits), head: mapOffset(selection.head, edits) })) };
     }
+
     const carets: Selection[] = new Array<Selection>(selections.length);
     let shift = 0;
+
     for (const [position, { from, to, index }] of ordered.entries()) {
         const piece = segments?.[position] ?? text;
         const inserted = options.reindent && segments === null && source.context(from).mode === 'code' ? reindent(source, from, piece, options) : piece;
@@ -109,5 +121,6 @@ export function planPaste(source: EditSource, selections: readonly Selection[],
         carets[index] = { anchor: head, head };
         shift += inserted.length - (to - from);
     }
+
     return { edits, selections: carets };
 }

package/src/php-markup.ts

@@ -12,9 +12,11 @@ function finishTag(state: TypingContext, selfClosing: boolean, script: ScriptLex
     state.markup = !selfClosing && state.element !== undefined ? 'raw' : undefined;
     state.markupQuote = undefined;
     state.embed = state.markup === 'raw' && state.element === 'script' ? script.initial() : undefined;
+
     if (state.embed !== undefined) {
         state.embed.embedStart = start;
     }
+
     if (selfClosing) {
         state.element = undefined;
     }
@@ -23,33 +25,42 @@ function finishTag(state: TypingContext, selfClosing: boolean, script: ScriptLex
 export function scanPhpMarkup(state: TypingContext, text: string, from: number, end: number, offset: number, script: ScriptLexer): number {
     for (let at = from; at < end; at++) {
         const char = text[at]!;
+
         if (char === '<' && text[at + 1] === '?') {
             PHP.lastIndex = at;
             const open = PHP.exec(text);
+
             if (open !== null) {
                 if (state.markup === 'equals') {
                     state.markup = 'value';
                 }
+
                 state.mode = 'code';
                 state.expression = true;
                 state.word = '';
+
                 return at + open[0].length - 1;
             }
         }
+
         if (state.markup === 'comment') {
             if (text.startsWith('-->', at) && at + 3 <= end) {
                 state.markup = undefined;
                 at += 2;
             }
+
             continue;
         }
+
         if (state.markup === 'value' && state.markupQuote !== undefined) {
             if (char === state.markupQuote) {
                 state.markup = 'tag';
                 state.markupQuote = undefined;
             }
+
             continue;
         }
+
         if (char === '<') {
             if (state.markup !== 'raw' && text.startsWith('<!--', at)) {
                 // HTML also closes these two comments immediately, without a later -->.
@@ -57,33 +68,44 @@ export function scanPhpMarkup(state: TypingContext, text: string, from: number,
                 state.markup = empty > 0 && at + empty <= end ? undefined : 'comment';
                 state.element = undefined;
                 at += (empty || 4) - 1;
+
                 continue;
             }
+
             TAG.lastIndex = at;
             const tag = TAG.exec(text);
             const name = tag?.[2]?.toLowerCase();
+
             if (state.markup === 'raw' && (tag?.[1] !== '/' || name !== state.element)) {
                 if (state.embed !== undefined) {
                     at = script.step(state.embed, text, at, end, offset);
                 }
+
                 continue;
             }
+
             state.embed = undefined;
             state.element = tag?.[1] !== '/' && (name === 'script' || name === 'style' || name === 'textarea' || name === 'title') ? name : undefined;
             state.markup = tag === null ? undefined : 'tag';
             state.markupQuote = undefined;
+
             if (tag !== null) {
                 at += tag[0].length - 1;
             }
+
             continue;
         }
+
         if (state.embed !== undefined) {
             at = script.step(state.embed, text, at, end, offset);
+
             continue;
         }
+
         if (state.markup === undefined || state.markup === 'raw') {
             continue;
         }
+
         if (char === '>') {
             finishTag(state, false, script, offset + at + 1);
         } else if (char === '/' && text[at + 1] === '>' && at + 2 <= end) {
@@ -100,5 +122,6 @@ export function scanPhpMarkup(state: TypingContext, text: string, from: number,
             state.markup = 'equals';
         }
     }
+
     return end - 1;
 }