@adecore/editor-core 0.39.0 → 0.40.1

package/src/preserve-case.ts

@@ -11,28 +11,36 @@ export function replaceWithCaseRespect(replacement: string, found: string): stri
     if (found === '' || replacement === '') {
         return replacement;
     }
+
     const [firstFound] = found;
     const [firstReplacement] = replacement;
     const head = upper.test(firstFound!) ? firstReplacement!.toUpperCase() : firstReplacement!.toLowerCase();
     const replacementTail = replacement.slice(firstReplacement!.length);
+
     if (replacementTail === '') {
         return head;
     }
+
     const foundTail = found.slice(firstFound!.length);
+
     if (foundTail === '') {
         return head + replacementTail;
     }
+
     const replacementCase = letterCase(replacementTail);
     const foundCase = letterCase(foundTail);
     // A tail without letters, like `x2`, follows the first letter of the match.
     const tailUpper = foundCase.hasLetters ? foundCase.upper : upper.test(firstFound!);
     const tailLower = foundCase.hasLetters ? foundCase.lower : lower.test(firstFound!);
+
     if (tailUpper && (replacementCase.lower || !replacementCase.upper)) {
         return head + replacementTail.toUpperCase();
     }
+
     if (tailLower && (replacementCase.lower || replacementCase.upper)) {
         return head + replacementTail.toLowerCase();
     }
+
     return head + replacementTail;
 }
 
@@ -41,16 +49,20 @@ function letterCase(text: string): { upper: boolean; lower: boolean; hasLetters:
     let allUpper = true;
     let allLower = true;
     let hasLetters = false;
+
     for (const character of text) {
         if (!letter.test(character)) {
             continue;
         }
+
         hasLetters = true;
         allUpper &&= upper.test(character);
         allLower &&= lower.test(character);
+
         if (!allUpper && !allLower) {
             break;
         }
     }
+
     return { upper: allUpper, lower: allLower, hasLetters };
 }

package/src/rope.ts

@@ -16,6 +16,7 @@ type Edges = { readonly startsWithLf: boolean; readonly endsWithCr: boolean };
 type Leaf = Edges & { readonly text: string; readonly breaks: readonly number[]; readonly length: number; readonly lines: number; readonly height: number };
 type Branch = Edges & { readonly left: Node; readonly right: Node; readonly length: number; readonly lines: number; readonly height: number };
 type Node = Leaf | Branch;
+
 export const ROPE_CHUNK_SIZE = 2048;
 
 const CR = 13;
@@ -30,13 +31,17 @@ function leaf(text: string): Leaf | null {
     if (!text.length) {
         return null;
     }
+
     const breaks: number[] = [];
+
     for (let index = 0; index < text.length; index++) {
         const code = text.charCodeAt(index);
+
         if (code === LF || (code === CR && text.charCodeAt(index + 1) !== LF)) {
             breaks.push(index);
         }
     }
+
     return {
         text,
         breaks,
@@ -65,16 +70,22 @@ function balance(left: Node, right: Node): Node {
         if (left.left.height >= left.right.height) {
             return branch(left.left, branch(left.right, right));
         }
+
         const middle = left.right as Branch;
+
         return branch(branch(left.left, middle.left), branch(middle.right, right));
     }
+
     if (right.height > left.height + 1 && 'left' in right) {
         if (right.right.height >= right.left.height) {
             return branch(branch(left, right.left), right.right);
         }
+
         const middle = right.left as Branch;
+
         return branch(branch(left, middle.left), branch(middle.right, right.right));
     }
+
     return branch(left, right);
 }
 
@@ -82,18 +93,23 @@ function join(left: Node | null, right: Node | null): Node | null {
     if (!left) {
         return right;
     }
+
     if (!right) {
         return left;
     }
+
     if ('text' in left && 'text' in right && left.length + right.length <= ROPE_CHUNK_SIZE) {
         return leaf(left.text + right.text);
     }
+
     if (left.height > right.height + 1 && 'left' in left) {
         return balance(left.left, join(left.right, right)!);
     }
+
     if (right.height > left.height + 1 && 'left' in right) {
         return balance(join(left, right.left)!, right.right);
     }
+
     return branch(left, right);
 }
 
@@ -101,35 +117,47 @@ function split(node: Node | null, offset: number): [Node | null, Node | null] {
     if (!node || offset <= 0) {
         return [null, node];
     }
+
     if (offset >= node.length) {
         return [node, null];
     }
+
     if ('text' in node) {
         return [leaf(node.text.slice(0, offset)), leaf(node.text.slice(offset))];
     }
+
     if (offset < node.left.length) {
         const [before, after] = split(node.left, offset);
+
         return [before, join(after, node.right)];
     }
+
     const [before, after] = split(node.right, offset - node.left.length);
+
     return [join(node.left, before), after];
 }
 
 function build(text: string): Node | null {
     const leaves: Node[] = [];
+
     for (let offset = 0; offset < text.length; offset += ROPE_CHUNK_SIZE) {
         leaves.push(leaf(text.slice(offset, offset + ROPE_CHUNK_SIZE))!);
     }
+
     const tree = (from: number, to: number): Node | null => {
         if (from === to) {
             return null;
         }
+
         if (to - from === 1) {
             return leaves[from]!;
         }
+
         const middle = (from + to) >>> 1;
+
         return branch(tree(from, middle)!, tree(middle, to)!);
     };
+
     return tree(0, leaves.length);
 }
 
@@ -137,13 +165,17 @@ function collect(node: Node | null, from: number, to: number, chunks: string[]):
     if (!node || from >= to) {
         return;
     }
+
     if ('text' in node) {
         chunks.push(node.text.slice(from, to));
+
         return;
     }
+
     if (from < node.left.length) {
         collect(node.left, from, Math.min(to, node.left.length), chunks);
     }
+
     if (to > node.left.length) {
         collect(node.right, Math.max(0, from - node.left.length), to - node.left.length, chunks);
     }
@@ -153,13 +185,17 @@ function* chunksOf(node: Node | null, from: number, to: number): Generator<strin
     if (!node || from >= to) {
         return;
     }
+
     if ('text' in node) {
         yield node.text.slice(from, to);
+
         return;
     }
+
     if (from < node.left.length) {
         yield* chunksOf(node.left, from, Math.min(to, node.left.length));
     }
+
     if (to > node.left.length) {
         yield* chunksOf(node.right, Math.max(0, from - node.left.length), to - node.left.length);
     }
@@ -181,9 +217,11 @@ export class TextRope {
     static from(text: string): TextRope {
         return new TextRope(build(text));
     }
+
     get length(): number {
         return this.root?.length ?? 0;
     }
+
     get lineCount(): number {
         return (this.root?.lines ?? 0) + 1;
     }
@@ -192,7 +230,9 @@ export class TextRope {
         if (offset < 0 || offset >= this.length) {
             return '';
         }
+
         let node = this.root!;
+
         while ('left' in node) {
             if (offset < node.left.length) {
                 node = node.left;
@@ -201,18 +241,21 @@ export class TextRope {
                 node = node.right;
             }
         }
+
         return node.text.charAt(offset);
     }
 
     slice(from = 0, to = this.length): string {
         const chunks: string[] = [];
         collect(this.root, clampInteger(from, this.length), clampInteger(to, this.length), chunks);
+
         return chunks.join('');
     }
 
     replace(from: number, to: number, text: string): TextRope {
         const [before, rest] = split(this.root, from);
         const [, after] = split(rest, to - from);
+
         return new TextRope(join(join(before, build(text)), after));
     }
 
@@ -223,26 +266,33 @@ export class TextRope {
         let column = 0;
         let offset = 0;
         const pieces: string[] = [];
+
         const advance = (end: number, keep: boolean): void => {
             while (offset < end && !chunk.done) {
                 const count = Math.min(end - offset, chunk.value.length - column);
+
                 if (keep) {
                     pieces.push(chunk.value.slice(column, column + count));
                 }
+
                 offset += count;
                 column += count;
+
                 if (column === chunk.value.length) {
                     chunk = chunks.next();
                     column = 0;
                 }
             }
         };
+
         for (const edit of edits) {
             advance(edit.from, true);
             pieces.push(edit.text);
             advance(edit.to, false);
         }
+
         advance(this.length, true);
+
         return TextRope.from(pieces.join(''));
     }
 
@@ -251,28 +301,35 @@ export class TextRope {
         if (this.root === other.root) {
             return true;
         }
+
         const left = chunksOf(this.root, from, to);
         const right = chunksOf(other.root, from, to);
         let leftChunk = left.next();
         let rightChunk = right.next();
         let leftAt = 0;
         let rightAt = 0;
+
         while (!leftChunk.done && !rightChunk.done) {
             const length = Math.min(leftChunk.value.length - leftAt, rightChunk.value.length - rightAt);
+
             if (leftChunk.value.slice(leftAt, leftAt + length) !== rightChunk.value.slice(rightAt, rightAt + length)) {
                 return false;
             }
+
             leftAt += length;
             rightAt += length;
+
             if (leftAt === leftChunk.value.length) {
                 leftChunk = left.next();
                 leftAt = 0;
             }
+
             if (rightAt === rightChunk.value.length) {
                 rightChunk = right.next();
                 rightAt = 0;
             }
         }
+
         return Boolean(leftChunk.done && rightChunk.done);
     }
 
@@ -280,9 +337,11 @@ export class TextRope {
         offset = clampInteger(offset, this.length);
         let node = this.root;
         let count = 0;
+
         if (!node) {
             return count;
         }
+
         while ('left' in node) {
             if (offset < node.left.length) {
                 node = node.left;
@@ -292,40 +351,50 @@ export class TextRope {
                 node = node.right;
             }
         }
+
         let low = 0;
         let high = node.breaks.length;
+
         while (low < high) {
             const middle = (low + high) >>> 1;
+
             if (node.breaks[middle]! < offset) {
                 low = middle + 1;
             } else {
                 high = middle;
             }
         }
+
         return count + low;
     }
 
     lineBounds(index: number): Omit<DocumentLine, 'text'> {
         index = clampInteger(index, this.lineCount - 1);
         const start = index === 0 ? 0 : this.breakAt(index - 1) + 1;
+
         if (index === this.lineCount - 1) {
             return { start, end: this.length, next: this.length };
         }
+
         const newline = this.breakAt(index);
         const crlf = this.charAt(newline) === '\n' && this.charAt(newline - 1) === '\r';
+
         return { start, end: newline - (crlf ? 1 : 0), next: newline + 1 };
     }
 
     getLine(index: number): DocumentLine {
         const bounds = this.lineBounds(index);
+
         return { ...bounds, text: this.slice(bounds.start, bounds.end) };
     }
 
     private breakAt(index: number): number {
         let node = this.root!;
         let offset = 0;
+
         while ('left' in node) {
             const leftLines = node.left.lines - sharedBreak(node.left, node.right);
+
             if (index < leftLines) {
                 node = node.left;
             } else {
@@ -334,6 +403,7 @@ export class TextRope {
                 node = node.right;
             }
         }
+
         return offset + node.breaks[index]!;
     }
 }

package/src/script-source.ts

@@ -5,19 +5,26 @@ export function scriptSource(text: string, start: number, complete: boolean, con
     const chunks: string[] = [];
     let cursor = 0;
     let island: number | undefined;
+
     const finish = (end: number): string => {
         chunks.push(text.slice(cursor, island ?? end));
+
         if (island !== undefined) {
             chunks.push(' '.repeat(end - island));
         }
+
         return chunks.join('');
     };
+
     for (const match of text.matchAll(events)) {
         const state = context(start + match.index);
+
         if (state === null) {
             return undefined;
         }
+
         const inScript = state.embedded === 'javascript' && state.embedStart === start;
+
         if (/^<\?(?:php\b|=)/.test(match[0])) {
             if (inScript) {
                 island = match.index;
@@ -25,11 +32,13 @@ export function scriptSource(text: string, start: number, complete: boolean, con
         } else if (match[0] === '?>') {
             if (island !== undefined && state.embed?.embedStart === start && (state.mode === 'code' || state.mode === 'line-comment')) {
                 let end = match.index + 2;
+
                 if (text.startsWith('\r\n', end)) {
                     end += 2;
                 } else if (text[end] === '\n') {
                     end++;
                 }
+
                 // Spaces preserve document offsets without treating PHP source newlines as script text.
                 chunks.push(text.slice(cursor, island), ' '.repeat(end - island));
                 cursor = end;
@@ -39,5 +48,6 @@ export function scriptSource(text: string, start: number, complete: boolean, con
             return finish(match.index);
         }
     }
+
     return complete ? finish(text.length) : undefined;
 }

package/src/search.ts

@@ -47,33 +47,44 @@ export function findMatches(text: string, query: string, revision: number, optio
 /* Validation and regex execution start when the iterator advances. */
 export function* iterateMatches(text: string, query: string, revision: number, options: FindOptions = {}): Generator<FindMatch, void, unknown> {
     options = { ...options };
+
     if (!query && !options.regex) {
         return;
     }
+
     const from = options.from ?? 0;
     const to = options.to ?? text.length;
     const maximum = options.maxResults ?? Infinity;
+
     if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to < from || to > text.length) {
         throw new RangeError('Search bounds must be ordered offsets inside the document.');
     }
+
     if (maximum !== Infinity && (!Number.isInteger(maximum) || maximum < 0)) {
         throw new RangeError('maxResults must be a nonnegative integer.');
     }
+
     const source = options.regex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     const expression = new RegExp(source, `gmu${options.caseSensitive ? '' : 'i'}`);
     expression.lastIndex = from;
     let count = 0;
+
     while (count < maximum) {
         const match = expression.exec(text);
+
         if (!match || match.index > to) {
             break;
         }
+
         const end = match.index + match[0].length;
+
         const wholeWord =
             !options.wholeWord ||
             (!wordCharacter.test(characterBefore(text, match.index)) && !wordCharacter.test(String.fromCodePoint(text.codePointAt(end) ?? 0)));
+
         if (match.index >= from && end <= to && !splitsSurrogate(text, match.index) && !splitsSurrogate(text, end) && wholeWord) {
             count++;
+
             yield {
                 from: match.index,
                 to: end,
@@ -84,6 +95,7 @@ export function* iterateMatches(text: string, query: string, revision: number, o
                 revision
             };
         }
+
         if (!match[0].length) {
             expression.lastIndex = match.index + ((text.codePointAt(match.index) ?? 0) > 0xffff ? 2 : 1);
         }
@@ -96,12 +108,15 @@ export function findMatchFrom(text: string, query: string, revision: number, off
     let first: FindMatch | null = null;
     let last: FindMatch | null = null;
     let previous: FindMatch | null = null;
+
     for (const match of iterateMatches(text, query, revision, options)) {
         first ??= match;
         last = match;
+
         if (!options.backwards && match.from >= position) {
             return match;
         }
+
         if (options.backwards) {
             if (match.to <= position) {
                 previous = match;
@@ -110,6 +125,7 @@ export function findMatchFrom(text: string, query: string, revision: number, off
             }
         }
     }
+
     return options.backwards ? (previous ?? (options.wrap === false ? null : last)) : options.wrap === false ? null : first;
 }
 
@@ -118,59 +134,81 @@ export function replacementText(text: string, match: FindMatch, replacement: str
     if (maxCharacters !== Infinity && (!Number.isSafeInteger(maxCharacters) || maxCharacters < 0)) {
         throw new RangeError('The replacement character limit must be nonnegative.');
     }
+
     const expanded = literal || !match.regex ? replacement : expandPatterns(text, match, replacement, maxCharacters);
+
     if (expanded.length > maxCharacters) {
         throw new RangeError('Replacement output exceeds its character limit.');
     }
+
     const result = preserveCase ? replaceWithCaseRespect(expanded, match.text) : expanded;
+
     if (result.length > maxCharacters) {
         throw new RangeError('Replacement output exceeds its character limit.');
     }
+
     return result;
 }
 
 function expandPatterns(text: string, match: FindMatch, replacement: string, maxCharacters: number): string {
     const pieces: string[] = [];
+
     let characters = 0,
         cursor = 0;
+
     const append = (value: string): void => {
         characters += value.length;
+
         if (characters > maxCharacters) {
             throw new RangeError('Replacement output exceeds its character limit.');
         }
+
         pieces.push(value);
     };
+
     const expand = (token: string, group: string): string => {
         if (group === '$') {
             return '$';
         }
+
         if (group === '&') {
             return match.text;
         }
+
         if (group === '`') {
             return text.slice(0, match.from);
         }
+
         if (group === "'") {
             return text.slice(match.to);
         }
+
         if (group.startsWith('<')) {
             return match.groups ? (match.groups[group.slice(1, -1)] ?? '') : token;
         }
+
         const index = Number(group);
+
         if (index > 0 && index <= match.captures.length) {
             return match.captures[index - 1] ?? '';
         }
+
         const first = Number(group[0]);
+
         if (group.length === 2 && first > 0 && first <= match.captures.length) {
             return (match.captures[first - 1] ?? '') + group[1];
         }
+
         return token;
     };
+
     for (const found of replacement.matchAll(/\$(\$|&|`|'|\d{1,2}|<[^>]*>)/g)) {
         append(replacement.slice(cursor, found.index));
         append(expand(found[0], found[1]!));
         cursor = found.index + found[0].length;
     }
+
     append(replacement.slice(cursor));
+
     return pieces.join('');
 }