@adecore/editor-react 0.39.0 → 0.40.1

package/src/doc-comment-model.ts

@@ -35,36 +35,47 @@ const ALIASES: Readonly<Record<string, string>> = {
 
 /* Tags that carry a type before their subject. */
 const TYPED = new Set(['param', 'property', 'return', 'throws', 'var', 'type', 'yield', 'template', 'this']);
+
 /* Tags whose first word is the thing they are about. */
 const SUBJECT_FIRST = new Set(['param', 'property', 'var', 'template']);
 
 const TAG_START = /^@([A-Za-z][\w-]*)(?::[\w-]+)?[ \t]*(.*)$/;
 const FENCE = /^\s*(```|~~~)/;
 const DASH = /^[—–-][ \t]+/;
+
 const DANGEROUS =
     /<(script|style|iframe|object|embed|svg|math|form)\b[\s\S]*?<\/\1\s*>|<\/?(script|style|iframe|object|embed|link|meta|base|svg|math|form|img|video|audio|source|input|button|textarea|select|canvas|frame|frameset)\b[^>]*>/gi;
+
 const SAFE_SCHEME = /^(https?:|mailto:)/i;
 
 /* Reads a type that starts the text: in braces as JSDoc writes it, or as one word with its brackets as PHPDoc does. */
 function takeType(text: string, braces: boolean): { type: string | null; rest: string } {
     const trimmed = text.trimStart();
+
     if (trimmed.startsWith('{')) {
         let depth = 0;
+
         for (let i = 0; i < trimmed.length; i++) {
             depth += trimmed[i] === '{' ? 1 : trimmed[i] === '}' ? -1 : 0;
+
             if (depth === 0) {
                 return { type: trimmed.slice(1, i).trim(), rest: trimmed.slice(i + 1).trimStart() };
             }
         }
+
         return { type: null, rest: trimmed };
     }
+
     if (braces || /^[$&.]/.test(trimmed)) {
         return { type: null, rest: trimmed };
     }
+
     let depth = 0;
     let end = 0;
+
     for (; end < trimmed.length; end++) {
         const character = trimmed[end]!;
+
         if ('<([{'.includes(character)) {
             depth++;
         } else if ('>)]}'.includes(character)) {
@@ -73,19 +84,24 @@ function takeType(text: string, braces: boolean): { type: string | null; rest: s
             break;
         }
     }
+
     return { type: end === 0 ? null : trimmed.slice(0, end), rest: trimmed.slice(end).trimStart() };
 }
 
 /* The first word of a tag's text: a name with its sigils and the `[name=default]` form of JSDoc. */
 function takeSubject(text: string): { subject: string | null; rest: string } {
     const optional = /^\[([^\]]+)\]\s*/.exec(text);
+
     if (optional !== null) {
         return { subject: optional[1]!, rest: text.slice(optional[0].length) };
     }
+
     const word = /^(?:\.\.\.|&)?[$\w.\\:-]+/.exec(text);
+
     if (word === null) {
         return { subject: null, rest: text };
     }
+
     return { subject: word[0], rest: text.slice(word[0].length).trimStart() };
 }
 
@@ -94,11 +110,14 @@ function splitTags(body: string): { description: string; raw: { name: string; te
     const description: string[] = [];
     const raw: { name: string; text: string }[] = [];
     let fenced = false;
+
     for (const line of body.split('\n')) {
         if (FENCE.test(line)) {
             fenced = !fenced;
         }
+
         const start = fenced ? null : TAG_START.exec(line.trimStart());
+
         if (start !== null) {
             raw.push({ name: start[1]!.toLowerCase(), text: start[2]! });
         } else if (raw.length > 0) {
@@ -107,6 +126,7 @@ function splitTags(body: string): { description: string; raw: { name: string; te
             description.push(line);
         }
     }
+
     return { description: description.join('\n').trim(), raw };
 }
 
@@ -114,10 +134,12 @@ function entryOf(name: string, text: string, php: boolean): DocTagEntry {
     let rest = text.trim();
     let type: string | null = null;
     let subject: string | null = null;
+
     if (TYPED.has(name)) {
         const taken = name === 'return' && rest.startsWith('$this') ? { type: '$this', rest: rest.slice(5).trimStart() } : takeType(rest, !php);
         type = taken.type;
         rest = taken.rest;
+
         // A type that stands alone is the whole text of a tag that has no subject.
         if (SUBJECT_FIRST.has(name) || (name === 'throws' && type === null)) {
             const word = takeSubject(rest);
@@ -129,10 +151,12 @@ function entryOf(name: string, text: string, php: boolean): DocTagEntry {
         subject = target === null ? null : target[0];
         rest = target === null ? rest : rest.slice(target[0].length).trimStart();
     }
+
     if (name === 'throws' && type === null && subject !== null) {
         type = subject;
         subject = null;
     }
+
     return { name, type, subject, text: rest.replace(DASH, '').trim() };
 }
 
@@ -151,16 +175,19 @@ export function decodeEntities(text: string): string {
     return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, code: string) => {
         if (code[0] === '#') {
             const point = code[1]!.toLowerCase() === 'x' ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+
             return Number.isFinite(point) && point > 0 && point <= 0x10ffff ? String.fromCodePoint(point) : match;
         }
+
         return ENTITIES[code.toLowerCase()] ?? match;
     });
 }
 
-function dedent(text: string): string {
+export function dedent(text: string): string {
     const lines = text.replace(/^\n+|\s+$/g, '').split('\n');
     const indents = lines.filter((line) => line.trim() !== '').map((line) => line.length - line.trimStart().length);
     const common = indents.length === 0 ? 0 : Math.min(...indents);
+
     return lines.map((line) => line.slice(common)).join('\n');
 }
 
@@ -175,6 +202,7 @@ function stripTags(html: string): string {
 /* The address of a link when it is one a reader may follow; null for everything else, such as a script address. */
 export function safeAddress(address: string): string | null {
     const trimmed = decodeEntities(address.trim());
+
     return SAFE_SCHEME.test(trimmed) || trimmed.startsWith(DOC_LINK_PREFIX) ? trimmed.replace(/\s/g, '%20').replace(/\(/g, '%28').replace(/\)/g, '%29') : null;
 }
 
@@ -188,12 +216,15 @@ export function htmlToMarkdown(source: string): string {
     if (!source.includes('<') && !source.includes('&')) {
         return source;
     }
+
     const lists: ('ul' | 'ol')[] = [];
     const counters: number[] = [];
     let anchor: string | null = null;
+
     const blocks = source
         .replace(/<pre\b[^>]*>([\s\S]*?)<\/pre\s*>/gi, (_match, body: string) => fenced(body))
         .replace(/<code>([^<]*\n[^<]*)<\/code>/gi, (_match, body: string) => fenced(body));
+
     const converted = outsideCode(blocks, (text) =>
         text
             .replace(DANGEROUS, '')
@@ -201,6 +232,7 @@ export function htmlToMarkdown(source: string): string {
                 /<(\/?)(p|br|b|strong|i|em|u|code|tt|kbd|samp|var|a|ul|ol|li|h[1-6]|blockquote|hr|div|span|dl|dt|dd|sup|sub|small|center)\b([^>]*?)(\/?)>/gi,
                 (_match, close: string, tag: string, attributes: string) => {
                     const closing = close === '/';
+
                     switch (tag.toLowerCase()) {
                         case 'p':
                         case 'div':
@@ -226,10 +258,13 @@ export function htmlToMarkdown(source: string): string {
                             if (closing) {
                                 const target = anchor;
                                 anchor = null;
+
                                 return target === null ? '' : `](${target})`;
                             }
+
                             const href = /\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(attributes);
                             anchor = href === null ? null : safeAddress(href[1] ?? href[2] ?? href[3] ?? '');
+
                             return anchor === null ? '' : '[';
                         }
                         case 'ul':
@@ -241,13 +276,16 @@ export function htmlToMarkdown(source: string): string {
                                 lists.push(tag.toLowerCase() as 'ul' | 'ol');
                                 counters.push(0);
                             }
+
                             return '\n';
                         case 'li': {
                             if (closing) {
                                 return '';
                             }
+
                             const depth = Math.max(0, lists.length - 1);
                             const marker = lists.at(-1) === 'ol' ? `${(counters[depth] = (counters[depth] ?? 0) + 1)}.` : '-';
+
                             return `\n${'  '.repeat(depth)}${marker} `;
                         }
                         case 'blockquote':
@@ -260,11 +298,13 @@ export function htmlToMarkdown(source: string): string {
                             if (/^h[1-6]$/i.test(tag)) {
                                 return closing ? '\n\n' : `\n\n${'#'.repeat(Number(tag[1]))} `;
                             }
+
                             return '';
                     }
                 }
             )
     );
+
     // Entities last, so `&lt;b&gt;` stays the text it spells and is not read as a tag above.
     return outsideCode(converted, decodeEntities).replace(/\n{3,}/g, '\n\n');
 }
@@ -279,6 +319,7 @@ export function inlineTagsToMarkdown(markdown: string): string {
             .replace(/\{@(?:link|linkcode|linkplain|see)\s+([^}\s|]+)(?:\s*[|\s]\s*([^}]+?))?\s*\}/g, (_match, target: string, label: string | undefined) => {
                 const address = /^https?:\/\//i.test(target) ? safeAddress(target) : `${DOC_LINK_PREFIX}${encodeURIComponent(target)}`;
                 const shown = label ?? target;
+
                 return address === null ? `\`${shown}\`` : `[${label === undefined ? `\`${shown}\`` : shown}](${address})`;
             })
             .replace(/\{@code\s+([^}]*)\}/g, (_match, code: string) => `\`${code.trim()}\``)
@@ -290,6 +331,7 @@ export function inlineTagsToMarkdown(markdown: string): string {
 function exampleOf(text: string): string {
     const code = text.replace(/^\s*<caption>[\s\S]*?<\/caption>[ \t]*\n?/i, '');
     const [head = '', ...tail] = code.split('\n');
+
     return head.trim() === '' ? dedent(code) : [head.trim(), dedent(tail.join('\n'))].join('\n').trim();
 }
 
@@ -301,16 +343,20 @@ function proseOf(text: string): string {
 export function parseDocComment(body: string, options: { php?: boolean } = {}): ParsedDocComment {
     const php = options.php === true;
     const { description, raw } = splitTags(body);
+
     const tags = raw.map(({ name, text }) => {
         const bare = name.replace(/^(?:psalm|phpstan)-/, '');
         const canonical = ALIASES[bare] ?? bare;
         const entry = entryOf(canonical, text, php);
+
         // An example is code: it keeps its lines and gets no prose treatment, only its caption removed.
         if (canonical === 'example') {
             return { ...entry, text: exampleOf(text) };
         }
+
         return { ...entry, text: proseOf(entry.text) };
     });
+
     return { description: proseOf(description), tags };
 }
 
@@ -325,12 +371,16 @@ export interface DocTagSection {
 /* The tags gathered by name, so a list of parameters is one section, in reading order. */
 export function sectionsOf(tags: readonly DocTagEntry[]): DocTagSection[] {
     const byName = new Map<string, DocTagEntry[]>();
+
     for (const tag of tags) {
         byName.set(tag.name, [...(byName.get(tag.name) ?? []), tag]);
     }
+
     const rank = (name: string): number => {
         const index = ORDER.indexOf(name);
+
         return index === -1 ? ORDER.length : index;
     };
+
     return [...byName].map(([name, entries]) => ({ name, tags: entries })).sort((left, right) => rank(left.name) - rank(right.name));
 }

package/src/editor-language.ts

@@ -50,8 +50,10 @@ export class EditorLanguage {
     readonly project: ProjectLanguage;
     readonly document: LanguageDocumentHandle;
     readonly languageId: string;
+
     /* What the features of this editor have open over it: the hover card, the suggestions, the signature. */
     readonly popups = createPopupStore();
+
     readonly diagnostics: DiagnosticsFeature;
     readonly hover: HoverFeature;
     readonly inlayHints: InlayHintsFeature;
@@ -161,6 +163,7 @@ export class EditorLanguage {
      */
     onProvidersChanged(listener: () => void): () => void {
         let listening = true;
+
         void this.document.ready.then(
             () => {
                 if (listening && !this.disposed) {
@@ -169,11 +172,13 @@ export class EditorLanguage {
             },
             () => undefined
         );
+
         const providers = this.project.service.onProvidersChanged((uri) => {
             if (uri === this.uri) {
                 listener();
             }
         });
+
         return () => {
             listening = false;
             providers.dispose();
@@ -197,20 +202,26 @@ export class EditorLanguage {
         if (this.disposed) {
             return;
         }
+
         this.disposed = true;
+
         for (const dispose of this.disposers.splice(0).reverse()) {
             dispose();
         }
+
         this.document.release();
     }
 
     /* A file opened from another one lands on the line; this puts the caret on the column the jump meant. */
     private placeOpenedCaret(position: EditorPosition): void {
         const column = this.project.takeCaret(this.uri, position.line);
+
         if (column !== null && column.character !== position.character) {
             this.editor.setCaret(column);
+
             return;
         }
+
         this.project.noteCaret({ uri: this.uri, position });
     }
 }

package/src/find-query.ts

@@ -34,10 +34,12 @@ export function compileFind(query: FindQuery): CompiledFind {
     if (query.text === '') {
         return { kind: 'empty' };
     }
+
     const body = query.regex ? query.text : escapeRegExp(query.text);
     const source = query.wholeWord ? `(?<!${WORD_CHAR})(?:${body})(?!${WORD_CHAR})` : body;
     // Multiline, so `^` and `$` in a pattern mean a line, the way an editor's find reads them.
     const flags = `gmu${query.caseSensitive ? '' : 'i'}`;
+
     try {
         return { kind: 'pattern', pattern: new RegExp(source, flags) };
     } catch {
@@ -50,6 +52,7 @@ export function matchesIn(text: string, pattern: RegExp, limit: number = MATCH_L
     const matches: TextMatch[] = [];
     const global = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`);
     let found = global.exec(text);
+
     while (found !== null && matches.length < limit) {
         if (found[0] === '') {
             // A `u` pattern moves a lastIndex inside a surrogate pair back to its start, so one step would never leave it.
@@ -57,8 +60,10 @@ export function matchesIn(text: string, pattern: RegExp, limit: number = MATCH_L
         } else {
             matches.push({ start: found.index, end: found.index + found[0].length });
         }
+
         found = global.exec(text);
     }
+
     return matches;
 }
 
@@ -67,8 +72,10 @@ export function stepIndex(current: number | null, count: number, direction: 1 |
     if (count === 0) {
         return null;
     }
+
     if (current === null) {
         return direction === 1 ? 0 : count - 1;
     }
+
     return (current + direction + count) % count;
 }

package/src/folding.ts

@@ -1,4 +1,4 @@
-import type { EditorFoldHints, EditorFoldRangeHint, EditorFoldSymbol } from '@adecore/editor';
+import type { EditorFoldRangeHint, EditorFoldSymbol } from '@adecore/editor';
 import type { DocumentSymbolResult, FoldingRange } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
 import { Refresher } from './refresher.ts';
@@ -27,6 +27,7 @@ const BODIES: Readonly<Record<number, EditorFoldSymbol['body']>> = {
 export function foldSymbolsOf(result: DocumentSymbolResult): EditorFoldSymbol[] {
     return symbolSpansOf(result).flatMap(({ kind, range }) => {
         const body = BODIES[kind];
+
         return body !== undefined && range.end.line > range.start.line ? [{ range, body }] : [];
     });
 }
@@ -58,12 +59,15 @@ export class FoldingFeature {
     constructor(language: EditorLanguage, onSymbols: (listener: (result: DocumentSymbolResult) => void) => () => void, timers: Timers = realTimers) {
         this.language = language;
         const { editor, project, uri } = language;
+
         this.refresher = new Refresher(
             async (signal) => {
                 if (!project.service.supports(METHOD, uri)) {
                     return;
                 }
+
                 const ranges = await project.service.foldingRanges(uri, { signal });
+
                 if (!signal.aborted) {
                     this.ranges = foldRangesOf(ranges);
                     this.publish();
@@ -72,14 +76,18 @@ export class FoldingFeature {
             PAUSE_MS,
             timers
         );
+
         const symbols = onSymbols((result) => {
             this.symbols = foldSymbolsOf(result);
             this.publish();
         });
+
         const edits = editor.onTextChange(() => this.refresher.later());
+
         const providers = language.onProvidersChanged(() => {
             this.refresher.now();
         });
+
         language.onDispose(() => {
             symbols();
             edits();
@@ -90,7 +98,6 @@ export class FoldingFeature {
     }
 
     private publish(): void {
-        const hints: EditorFoldHints = { symbols: this.symbols, ranges: this.ranges };
-        this.language.editor.setFoldHints(hints);
+        this.language.editor.setFoldHints({ symbols: this.symbols, ranges: this.ranges });
     }
 }

package/src/format-on-type.ts

@@ -4,40 +4,42 @@ import { comparePositions } from './diagnostics-model.ts';
 import type { EditorLanguage } from './editor-language.ts';
 
 const METHOD = 'textDocument/onTypeFormatting';
+
 /* A line break with the indentation the editor put after it, which is how Enter reaches the server. */
 const LINE_BREAK = /^\r?\n[ \t]*(\r?\n[ \t]*)?$/;
+
 /* A closer with the whitespace the editor replaced in front of it when it moved the closer back to its opener's indentation. */
 const DEDENTED = /^[ \t]+(\S)$/u;
 
 /* The overlapping edits of a server answer have no single meaning, so an answer that has them is not applied. */
 function overlaps(edits: readonly TextEdit[]): boolean {
     const ordered = [...edits].sort((left, right) => comparePositions(left.range.start, right.range.start));
+
     return ordered.some((edit, index) => index > 0 && comparePositions(ordered[index - 1]!.range.end, edit.range.start) > 0);
 }
 
 /*
- * Formatting while typing: after a person types one of the characters the server named in
- * `firstTriggerCharacter` and `moreTriggerCharacter`, the server is asked what to change around the caret, and its
- * edits are applied.
+ * Formatting while typing: after one of the server's trigger characters is typed, the server is asked what
+ * to change around the caret, and its edits join the undo step of the typed character.
  *
- * Only typing counts: one change that is the trigger character alone, the closer the editor moved back to its
- * opener's indentation, or a line break with its indentation for `\n`, which the editor reports as typed though
- * Enter runs as a command. A character the editor types over an existing closer changes no text and asks nothing. A paste, undo, a completion or an external change does not ask, and neither does a
- * second caret, a read-only editor or a snippet session, whose tab stops an edit could move. An answer is applied
- * only while the text is exactly what it was asked about, and the caret where it was.
- *
- * The edits join the undo step of the typed character, so one undo takes both back. Off by default; a host enables it explicitly with `configure(true)`.
+ * Only typing counts: the trigger character alone, the closer the editor moved back to its opener's
+ * indentation, or a line break with its indentation for `\n`. A paste, undo, a completion, an external change,
+ * a second caret, a read-only editor or a snippet session (whose tab stops an edit could move) asks nothing.
+ * An answer is applied only while the text and the caret are what it was asked about. Off until `configure(true)`.
  */
 export class FormatOnTypeFeature {
     private readonly language: EditorLanguage;
     private enabled = false;
+
     /* Raised by every change of the text, so an answer for an older text is told from the one for the text that is. */
     private revision = 0;
+
     private controller = new AbortController();
 
     constructor(language: EditorLanguage) {
         this.language = language;
         const off = language.editor.onTextChange((change) => this.typed(change));
+
         language.onDispose(() => {
             off();
             this.controller.abort();
@@ -51,11 +53,13 @@ export class FormatOnTypeFeature {
     /* Whether the server of this document formats on type and the service can ask it. */
     get supported(): boolean {
         const { project, uri } = this.language;
+
         return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
     }
 
     configure(enabled: boolean): void {
         this.enabled = enabled;
+
         if (!enabled) {
             this.controller.abort();
         }
@@ -64,6 +68,7 @@ export class FormatOnTypeFeature {
     /* The characters that ask the server, the first one and the more. */
     triggerCharacters(): readonly string[] {
         const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+
         return options === undefined
             ? []
             : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
@@ -72,33 +77,41 @@ export class FormatOnTypeFeature {
     private typed(change: EditorTextChange): void {
         const revision = ++this.revision;
         this.controller.abort();
+
         if (!this.enabled || (change.source !== 'input' && change.typed !== true) || change.changes.length !== 1 || !this.supported) {
             return;
         }
+
         const { editor, snippets } = this.language;
         const { text } = change.changes[0]!;
         const typed = LINE_BREAK.test(text) ? '\n' : Array.from(text).length === 1 ? text : (DEDENTED.exec(text)?.[1] ?? null);
+
         if (typed === null || !this.triggerCharacters().includes(typed)) {
             return;
         }
+
         if (snippets.isActive || editor.isReadOnly?.() === true || editor.getSelections().length !== 1) {
             return;
         }
+
         this.controller = new AbortController();
         void this.ask(revision, typed, editor.getCaret(), this.controller.signal);
     }
 
     private async ask(revision: number, typed: string, caret: { line: number; character: number }, signal: AbortSignal): Promise<void> {
         const { editor, project, uri, document } = this.language;
+
         try {
             // The change of the typed character reaches the server before this question does.
             await document.ready;
             const edits = await project.service.onTypeFormatting!(uri, caret, typed, { ...editor.getIndentation() }, { signal });
             const here = editor.getCaret();
             const stale = revision !== this.revision || this.language.isDisposed || comparePositions(here, caret) !== 0;
+
             if (stale || edits === null || edits.length === 0 || overlaps(edits)) {
                 return;
             }
+
             editor.applyEdits(
                 edits.map((edit) => ({ range: edit.range, text: edit.newText })),
                 { mergeUndo: true }

package/src/highlight-layers.ts

@@ -21,6 +21,7 @@ export class HighlightLayers {
         } else {
             this.owners.set(owner, provider);
         }
+
         this.editor.setLineHighlights([...this.owners.values()].flatMap((read) => read()));
     }
 }
@@ -29,9 +30,11 @@ const layers = new WeakMap<Editor, HighlightLayers>();
 
 export function highlightLayers(editor: Editor): HighlightLayers {
     let found = layers.get(editor);
+
     if (found === undefined) {
         found = new HighlightLayers(editor);
         layers.set(editor, found);
     }
+
     return found;
 }

package/src/highlights.ts

@@ -25,10 +25,13 @@ export function neighborRange(ranges: readonly EditorRange[], from: EditorPositi
     if (ranges.length === 0) {
         return null;
     }
+
     const ordered = [...ranges].sort((left, right) => comparePositions(left.start, right.start));
+
     if (direction === 1) {
         return ordered.find((range) => comparePositions(range.start, from) > 0) ?? ordered[0]!;
     }
+
     return [...ordered].reverse().find((range) => comparePositions(range.start, from) < 0) ?? ordered[ordered.length - 1]!;
 }
 
@@ -44,13 +47,17 @@ export class HighlightsFeature {
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
         const { editor, project, uri } = language;
+
         this.refresher = new Refresher(
             async (signal) => {
                 if (!project.service.supports(METHOD, uri) || !this.onName()) {
                     this.clear();
+
                     return;
                 }
+
                 const result = await project.service.documentHighlights(uri, editor.getCaret(), { signal });
+
                 if (!signal.aborted) {
                     this.set(result === null ? [] : editorHighlightsOf(result));
                 }
@@ -58,12 +65,14 @@ export class HighlightsFeature {
             PAUSE_MS,
             timers
         );
+
         const offs = [
             editor.onCaret((position) => {
                 // Moving along the same name keeps its marks, which is what makes stepping through them quiet.
                 if (!this.current.some((highlight) => rangeHolds(highlight.range, position))) {
                     this.clear();
                 }
+
                 this.refresher.later();
             }),
             editor.onTextChange(() => {
@@ -73,16 +82,20 @@ export class HighlightsFeature {
             }),
             language.onKey((event) => {
                 const next = isShortcut(this.language.shortcuts.nextHighlight, event);
+
                 if (!next && !isShortcut(this.language.shortcuts.previousHighlight, event)) {
                     return false;
                 }
+
                 return this.step(next ? 1 : -1);
             }, KEY_PRIORITY.highlights)
         ];
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
             }
+
             this.refresher.dispose();
             editor.setHighlights([]);
         });
@@ -91,15 +104,19 @@ export class HighlightsFeature {
     /* Puts the caret on the next use of the name, or the one before; false when there are none. */
     step(direction: 1 | -1): boolean {
         const { editor } = this.language;
+
         const target = neighborRange(
             this.current.map((highlight) => highlight.range),
             editor.getCaret(),
             direction
         );
+
         if (target === null) {
             return false;
         }
+
         editor.setCaret(target.start, comparePositions(target.start, editor.getCaret()) > 0 ? 'centerDown' : 'centerUp');
+
         return true;
     }
 
@@ -108,6 +125,7 @@ export class HighlightsFeature {
         const caret = editor.getCaret();
         const before = caret.character > 0 ? editor.textInRange({ start: { line: caret.line, character: caret.character - 1 }, end: caret }) : '';
         const after = editor.textInRange({ start: caret, end: { line: caret.line, character: caret.character + 1 } });
+
         return (before !== '' && isIdentifierCharacter(before)) || (after !== '' && isIdentifierCharacter(after));
     }