@adecore/editor-react 0.0.1 → 0.17.0-beta.2

package/dist/shortcut-keys.d.ts

@@ -0,0 +1,91 @@
+import { type Keymap } from '@adecore/editor/keymap';
+import type { KeyChord } from '@adecore/editor';
+export interface LanguageShortcut extends KeyChord {
+    readonly apple: boolean;
+}
+export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
+    rename: LanguageShortcut | null;
+    acceptGhostWord: LanguageShortcut | null;
+    addCaretAbove: LanguageShortcut | null;
+    addCaretBelow: LanguageShortcut | null;
+    addCaretPerSelectedLine: LanguageShortcut | null;
+    autoIndentLines: LanguageShortcut | null;
+    codeActions: LanguageShortcut | null;
+    collapse: LanguageShortcut | null;
+    collapseAll: LanguageShortcut | null;
+    collapseDocComments: LanguageShortcut | null;
+    collapseRecursively: LanguageShortcut | null;
+    deleteLine: LanguageShortcut | null;
+    deleteWordLeft: LanguageShortcut | null;
+    deleteWordRight: LanguageShortcut | null;
+    duplicateLine: LanguageShortcut | null;
+    expand: LanguageShortcut | null;
+    expandAll: LanguageShortcut | null;
+    expandAllToLevel1: LanguageShortcut | null;
+    expandAllToLevel2: LanguageShortcut | null;
+    expandAllToLevel3: LanguageShortcut | null;
+    expandAllToLevel4: LanguageShortcut | null;
+    expandAllToLevel5: LanguageShortcut | null;
+    expandDocComments: LanguageShortcut | null;
+    expandRecursively: LanguageShortcut | null;
+    expandSelection: LanguageShortcut | null;
+    findNext: LanguageShortcut | null;
+    findPrevious: LanguageShortcut | null;
+    foldSelection: LanguageShortcut | null;
+    formatDocument: LanguageShortcut | null;
+    goToDefinition: LanguageShortcut | null;
+    goToImplementation: LanguageShortcut | null;
+    goToSymbol: LanguageShortcut | null;
+    goToTypeDefinition: LanguageShortcut | null;
+    historyBack: LanguageShortcut | null;
+    historyForward: LanguageShortcut | null;
+    inlineEdit: LanguageShortcut | null;
+    joinLines: LanguageShortcut | null;
+    matchBrace: LanguageShortcut | null;
+    moveLineDown: LanguageShortcut | null;
+    moveLineUp: LanguageShortcut | null;
+    nextHighlight: LanguageShortcut | null;
+    nextProblem: LanguageShortcut | null;
+    organizeImports: LanguageShortcut | null;
+    parameterInfo: LanguageShortcut | null;
+    peekDefinition: LanguageShortcut | null;
+    peekReferences: LanguageShortcut | null;
+    previousHighlight: LanguageShortcut | null;
+    previousProblem: LanguageShortcut | null;
+    quickInfo: LanguageShortcut | null;
+    recentLocations: LanguageShortcut | null;
+    redo: LanguageShortcut | null;
+    refactorThis: LanguageShortcut | null;
+    renameSymbol: LanguageShortcut | null;
+    replace: LanguageShortcut | null;
+    save: LanguageShortcut | null;
+    selectAll: LanguageShortcut | null;
+    selectAllOccurrences: LanguageShortcut | null;
+    selectNextOccurrence: LanguageShortcut | null;
+    selectSmartEnd: LanguageShortcut | null;
+    selectSmartHome: LanguageShortcut | null;
+    selectTextEnd: LanguageShortcut | null;
+    selectTextStart: LanguageShortcut | null;
+    selectWordLeft: LanguageShortcut | null;
+    selectWordRight: LanguageShortcut | null;
+    selectionToChat: LanguageShortcut | null;
+    shrinkSelection: LanguageShortcut | null;
+    smartEnd: LanguageShortcut | null;
+    smartHome: LanguageShortcut | null;
+    splitLine: LanguageShortcut | null;
+    startNewLine: LanguageShortcut | null;
+    startNewLineBefore: LanguageShortcut | null;
+    suggestInline: LanguageShortcut | null;
+    textEnd: LanguageShortcut | null;
+    textStart: LanguageShortcut | null;
+    toggleBlockComment: LanguageShortcut | null;
+    toggleCase: LanguageShortcut | null;
+    toggleColumnMode: LanguageShortcut | null;
+    toggleLineComment: LanguageShortcut | null;
+    triggerCompletion: LanguageShortcut | null;
+    undo: LanguageShortcut | null;
+    unselectOccurrence: LanguageShortcut | null;
+    wordLeft: LanguageShortcut | null;
+    wordRight: LanguageShortcut | null;
+};
+export declare function isShortcut(target: LanguageShortcut | null, event: KeyboardEvent): boolean;

package/dist/shortcut-keys.js

@@ -0,0 +1,12 @@
+import { chordOf, KEYMAP_IDS, parseChord } from '@adecore/editor/keymap';
+import { matchesShortcut } from '@adecore/ui';
+export function shortcutsOf(keymap, apple) {
+    const shortcuts = Object.fromEntries(KEYMAP_IDS.map((id) => {
+        const text = chordOf(id, apple, keymap);
+        return [id, text === null ? null : { ...parseChord(text), apple }];
+    }));
+    return { ...shortcuts, rename: shortcuts.renameSymbol };
+}
+export function isShortcut(target, event) {
+    return target !== null && matchesShortcut(target, event, target.apple);
+}

package/dist/signature-model.d.ts

@@ -0,0 +1,18 @@
+import type { SignatureHelp, SignatureInformation } from '@adecore/lsp';
+export interface SignatureViewModel {
+    readonly label: string;
+    readonly active: {
+        readonly start: number;
+        readonly end: number;
+    } | null;
+    readonly parameterName: string;
+    readonly parameterDocumentation: string;
+    readonly documentation: string;
+    readonly index: number;
+    readonly count: number;
+}
+export declare function parameterSpan(signature: SignatureInformation, index: number): {
+    start: number;
+    end: number;
+} | null;
+export declare function signatureViewOf(help: SignatureHelp | null): SignatureViewModel | null;

package/dist/signature-model.js

@@ -0,0 +1,33 @@
+import { documentationText } from './completion-model.js';
+/* Where a parameter's label stands in the signature's: given as a pair of offsets, or as the text to find in it. */
+export function parameterSpan(signature, index) {
+    const parameter = signature.parameters?.[index];
+    if (parameter === undefined) {
+        return null;
+    }
+    if (typeof parameter.label !== 'string') {
+        const [start, end] = parameter.label;
+        return start >= 0 && end <= signature.label.length && start < end ? { start, end } : null;
+    }
+    const start = signature.label.indexOf(parameter.label);
+    return start < 0 ? null : { start, end: start + parameter.label.length };
+}
+export function signatureViewOf(help) {
+    if (help === null || help.signatures.length === 0) {
+        return null;
+    }
+    const index = Math.min(Math.max(0, help.activeSignature ?? 0), help.signatures.length - 1);
+    const signature = help.signatures[index];
+    const parameterIndex = signature.activeParameter ?? help.activeParameter ?? 0;
+    const active = parameterSpan(signature, parameterIndex);
+    const parameter = signature.parameters?.[parameterIndex];
+    return {
+        label: signature.label,
+        active,
+        parameterName: active === null ? '' : signature.label.slice(active.start, active.end).replace(/[?:].*$/s, ''),
+        parameterDocumentation: documentationText(parameter?.documentation),
+        documentation: documentationText(signature.documentation),
+        index,
+        count: help.signatures.length
+    };
+}

package/dist/signature.d.ts

@@ -0,0 +1,22 @@
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export declare class SignatureFeature {
+    private readonly language;
+    private readonly timers;
+    private timer;
+    private request;
+    private controller;
+    private help;
+    private anchor;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get isOpen(): boolean;
+    invoke(): void;
+    trigger(): void;
+    private cycle;
+    close(): void;
+    private options;
+    private edited;
+    private retrigger;
+    private ask;
+    private fetch;
+}

package/dist/signature.js

@@ -0,0 +1,150 @@
+import { signatureViewOf } from './signature-model.js';
+import { isShortcut } from './shortcut-keys.js';
+import { realTimers } from './timers.js';
+const METHOD = 'textDocument/signatureHelp';
+const PAUSE_MS = 60;
+/*
+ * The parameters of the call the caret is in, while its arguments are typed. It opens on a trigger
+ * character of the server, such as `(` and `,`, and asks again as the caret moves or the text changes,
+ * so the active parameter follows; the server answering nothing is the caret leaving the call.
+ */
+export class SignatureFeature {
+    language;
+    timers;
+    timer;
+    request = 0;
+    controller = null;
+    help = null;
+    anchor = null;
+    constructor(language, timers = realTimers) {
+        this.language = language;
+        this.timers = timers;
+        const { editor } = language;
+        const offs = [
+            editor.onTextChange((change) => this.edited(change)),
+            editor.onCaret(() => this.retrigger()),
+            editor.onBlur(() => this.close()),
+            editor.onKeyDown((event) => {
+                if (event.key === 'Escape' && this.isOpen) {
+                    this.close();
+                    return true;
+                }
+                if (isShortcut(this.language.shortcuts.parameterInfo, event)) {
+                    this.invoke();
+                    return true;
+                }
+                if ((event.key === 'ArrowUp' || event.key === 'ArrowDown') && !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey) {
+                    return this.cycle(event.key === 'ArrowDown' ? 1 : -1);
+                }
+                return false;
+            })
+        ];
+        language.onDispose(() => {
+            for (const off of offs) {
+                off();
+            }
+            this.close();
+        });
+    }
+    get isOpen() {
+        return this.language.popups.getState().signature !== null;
+    }
+    /* Asks for the parameters of the call at the caret, as its key does. */
+    invoke() {
+        this.ask({ triggerKind: 1, isRetrigger: false });
+    }
+    /* Asks for the parameters as if `(` had just been typed, which is what a call opened by a completion is. */
+    trigger() {
+        this.ask({ triggerKind: 2, triggerCharacter: '(', isRetrigger: false });
+    }
+    /* Shows the next overload, or the one before, while the card is up and has more than one; false when it has not, which leaves the arrow to the caret. */
+    cycle(step) {
+        const { help } = this;
+        if (help === null || help.signatures.length < 2 || !this.isOpen) {
+            return false;
+        }
+        const count = help.signatures.length;
+        const next = { ...help, activeSignature: (Math.min(Math.max(0, help.activeSignature ?? 0), count - 1) + step + count) % count };
+        const model = signatureViewOf(next);
+        if (model === null || this.anchor === null) {
+            return false;
+        }
+        this.help = next;
+        this.language.popups.setState({ signature: { anchor: this.anchor, model } });
+        return true;
+    }
+    close() {
+        this.request++;
+        this.controller?.abort();
+        this.timers.clear(this.timer);
+        this.help = null;
+        this.anchor = null;
+        if (this.isOpen) {
+            this.language.popups.setState({ signature: null });
+        }
+    }
+    options() {
+        const { project, uri } = this.language;
+        const options = project.service.providerOptions(METHOD, uri);
+        return options === undefined ? null : { triggers: options.triggerCharacters ?? [], retriggers: options.retriggerCharacters ?? [] };
+    }
+    edited(change) {
+        const options = this.options();
+        if (change.source !== 'input' || options === null) {
+            this.close();
+            return;
+        }
+        const text = change.changes.length === 1 ? change.changes[0].text : '';
+        const last = Array.from(text).at(-1) ?? '';
+        if (text.length === 1 && options.triggers.includes(last)) {
+            this.ask({ triggerKind: 2, triggerCharacter: last, isRetrigger: this.isOpen });
+        }
+        else if (this.isOpen) {
+            this.ask({
+                triggerKind: text.length === 1 && options.retriggers.includes(last) ? 2 : 3,
+                ...(options.retriggers.includes(last) ? { triggerCharacter: last } : {}),
+                isRetrigger: true
+            });
+        }
+    }
+    retrigger() {
+        if (this.isOpen) {
+            this.ask({ triggerKind: 3, isRetrigger: true });
+        }
+    }
+    ask(context) {
+        const { project, uri } = this.language;
+        if (!project.service.supports(METHOD, uri)) {
+            return;
+        }
+        this.timers.clear(this.timer);
+        const request = ++this.request;
+        const full = { ...context, ...(this.help === null ? {} : { activeSignatureHelp: this.help }) };
+        this.timer = this.timers.set(() => void this.fetch(full, request), PAUSE_MS);
+    }
+    async fetch(context, request) {
+        const { editor, project, uri } = this.language;
+        const caret = editor.getCaret();
+        this.controller?.abort();
+        const controller = new AbortController();
+        this.controller = controller;
+        let help;
+        try {
+            help = await project.service.signatureHelp(uri, caret, context, { signal: controller.signal });
+        }
+        catch {
+            return;
+        }
+        if (request !== this.request) {
+            return;
+        }
+        const model = signatureViewOf(help);
+        if (model === null) {
+            this.close();
+            return;
+        }
+        this.help = help;
+        this.anchor ??= caret;
+        this.language.popups.setState({ signature: { anchor: this.anchor, model } });
+    }
+}

package/dist/snippet-session.d.ts

@@ -0,0 +1,17 @@
+import type { EditorPosition } from '@adecore/editor';
+import type { EditorLanguage } from './editor-language.ts';
+import type { SnippetStop } from './snippet.ts';
+export declare function positionInInsertion(start: EditorPosition, text: string, offset: number): EditorPosition;
+export declare class SnippetFeature {
+    private readonly language;
+    private stops;
+    private current;
+    constructor(language: EditorLanguage);
+    get isActive(): boolean;
+    begin(start: EditorPosition, text: string, stops: readonly SnippetStop[]): void;
+    end(): void;
+    private visit;
+    private key;
+    private edited;
+    private moved;
+}

package/dist/snippet-session.js

@@ -0,0 +1,110 @@
+import { comparePositions, rangeHolds, shiftRange } from './diagnostics-model.js';
+/* Where an offset of inserted text lands when the text is put in at `start`. */
+export function positionInInsertion(start, text, offset) {
+    const lines = text.slice(0, offset).split(/\r\n|\r|\n/);
+    return lines.length === 1
+        ? { line: start.line, character: start.character + offset }
+        : { line: start.line + lines.length - 1, character: lines[lines.length - 1].length };
+}
+/*
+ * The tab stops of a snippet that was just inserted. The caret goes to the first one, with its default text
+ * selected; Tab goes on to the next and Shift+Tab back, and the last stop (`$0`, or the end of the text)
+ * ends it. Escape, a caret that leaves the snippet and any change that is not typing end it too. Typing in
+ * a stop does not touch the others: they follow the text, but a mirror of a stop is not edited along.
+ */
+export class SnippetFeature {
+    language;
+    stops = [];
+    current = 0;
+    constructor(language) {
+        this.language = language;
+        const { editor } = language;
+        const offs = [
+            editor.onKeyDown((event) => this.key(event)),
+            editor.onTextChange((change) => this.edited(change)),
+            editor.onCaret((position) => this.moved(position))
+        ];
+        language.onDispose(() => {
+            for (const off of offs) {
+                off();
+            }
+        });
+    }
+    get isActive() {
+        return this.stops.length > 0;
+    }
+    /* Puts the caret where the snippet says, and keeps the stops to go through when there is more than the last one. */
+    begin(start, text, stops) {
+        this.end();
+        if (stops.length === 0) {
+            return;
+        }
+        const ranges = stops.map((stop) => ({ start: positionInInsertion(start, text, stop.start), end: positionInInsertion(start, text, stop.end) }));
+        if (ranges.length === 1) {
+            this.language.editor.setCaret(ranges[0].start);
+            return;
+        }
+        this.stops = ranges;
+        this.visit(0);
+    }
+    end() {
+        this.stops = [];
+        this.current = 0;
+    }
+    visit(index) {
+        const { editor } = this.language;
+        const target = this.stops[index];
+        this.current = index;
+        if (comparePositions(target.start, target.end) === 0) {
+            editor.setCaret(target.start);
+        }
+        else {
+            editor.setSelection(target);
+        }
+        if (index === this.stops.length - 1) {
+            this.end();
+        }
+    }
+    key(event) {
+        if (!this.isActive || event.ctrlKey || event.metaKey || event.altKey) {
+            return false;
+        }
+        if (event.key === 'Tab') {
+            this.visit(event.shiftKey ? Math.max(0, this.current - 1) : this.current + 1);
+            return true;
+        }
+        if (event.key === 'Escape') {
+            this.end();
+            return true;
+        }
+        return false;
+    }
+    edited(change) {
+        if (!this.isActive) {
+            return;
+        }
+        if (change.source !== 'input') {
+            this.end();
+            return;
+        }
+        this.stops = this.stops.map((stop) => shiftRange(stop, change.changes));
+    }
+    /* A caret outside the stretch the stops span is a person moving on. */
+    moved(position) {
+        if (!this.isActive) {
+            return;
+        }
+        const hull = { start: this.stops[0].start, end: this.stops[this.stops.length - 1].end };
+        for (const stop of this.stops) {
+            if (comparePositions(stop.start, hull.start) < 0) {
+                hull.start = stop.start;
+            }
+            if (comparePositions(stop.end, hull.end) > 0) {
+                hull.end = stop.end;
+            }
+        }
+        if (!rangeHolds(hull, position)) {
+            this.end();
+        }
+    }
+}

package/dist/snippet.d.ts

@@ -0,0 +1,11 @@
+export interface SnippetStop {
+    readonly index: number;
+    readonly start: number;
+    readonly end: number;
+}
+export interface ParsedSnippet {
+    readonly text: string;
+    readonly stops: readonly SnippetStop[];
+}
+export declare function parseSnippet(snippet: string): ParsedSnippet;
+export declare function tabOrder(parsed: ParsedSnippet): SnippetStop[];

package/dist/snippet.js

@@ -0,0 +1,134 @@
+const NAME = '[A-Za-z_]\\w*';
+const TABSTOP = new RegExp(`^\\$(\\d+)|^\\$\\{(\\d+)\\}`);
+const PLACEHOLDER = /^\$\{(\d+):/;
+const CHOICE = /^\$\{(\d+)\|/;
+const DEFAULT_VARIABLE = new RegExp(`^\\$\\{${NAME}:`);
+const TRANSFORMED_VARIABLE = new RegExp(`^\\$\\{${NAME}/`);
+const BARE_VARIABLE = new RegExp(`^\\$${NAME}|^\\$\\{${NAME}\\}`);
+class SnippetParser {
+    text = '';
+    stops = [];
+    at = 0;
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    parse() {
+        this.sequence(false);
+        return { text: this.text, stops: this.stops };
+    }
+    /* Text up to the `}` that closes the placeholder this is in, which is left for the caller. */
+    sequence(nested) {
+        while (this.at < this.source.length) {
+            const character = this.source[this.at];
+            if (character === '}' && nested) {
+                return;
+            }
+            if (character === '\\' && /[\\$}]/.test(this.source[this.at + 1] ?? '')) {
+                this.text += this.source[this.at + 1];
+                this.at += 2;
+            }
+            else if (character === '$') {
+                this.dollar();
+            }
+            else {
+                this.text += character;
+                this.at++;
+            }
+        }
+    }
+    dollar() {
+        const rest = this.source.slice(this.at);
+        const tabstop = TABSTOP.exec(rest);
+        const placeholder = PLACEHOLDER.exec(rest);
+        const choice = CHOICE.exec(rest);
+        if (tabstop !== null) {
+            this.at += tabstop[0].length;
+            this.stops.push({ index: Number(tabstop[1] ?? tabstop[2]), start: this.text.length, end: this.text.length });
+        }
+        else if (placeholder !== null) {
+            this.at += placeholder[0].length;
+            const start = this.text.length;
+            this.sequence(true);
+            this.closeBrace();
+            this.stops.push({ index: Number(placeholder[1]), start, end: this.text.length });
+        }
+        else if (choice !== null) {
+            this.at += choice[0].length;
+            const start = this.text.length;
+            this.firstChoice();
+            this.stops.push({ index: Number(choice[1]), start, end: this.text.length });
+        }
+        else if (DEFAULT_VARIABLE.test(rest)) {
+            this.at += rest.indexOf(':') + 1;
+            this.sequence(true);
+            this.closeBrace();
+        }
+        else if (TRANSFORMED_VARIABLE.test(rest)) {
+            this.skipBraces();
+        }
+        else if (BARE_VARIABLE.test(rest)) {
+            this.at += BARE_VARIABLE.exec(rest)[0].length;
+        }
+        else {
+            this.text += '$';
+            this.at++;
+        }
+    }
+    closeBrace() {
+        if (this.source[this.at] === '}') {
+            this.at++;
+        }
+    }
+    /* The first of `a,b,c|}`, and the rest dropped. */
+    firstChoice() {
+        let first = true;
+        while (this.at < this.source.length && !(this.source[this.at] === '|' && this.source[this.at + 1] === '}')) {
+            const character = this.source[this.at];
+            if (character === '\\' && /[\\,|]/.test(this.source[this.at + 1] ?? '')) {
+                this.at++;
+                if (first) {
+                    this.text += this.source[this.at];
+                }
+            }
+            else if (character === ',') {
+                first = false;
+            }
+            else if (first) {
+                this.text += character;
+            }
+            this.at++;
+        }
+        this.at += 2;
+    }
+    /* Past the `}` that closes a `${name/regex/format/}` variable, which inserts nothing here. */
+    skipBraces() {
+        let depth = 0;
+        while (this.at < this.source.length) {
+            const character = this.source[this.at];
+            this.at += character === '\\' ? 2 : 1;
+            if (character === '{') {
+                depth++;
+            }
+            else if (character === '}' && --depth === 0) {
+                return;
+            }
+        }
+    }
+}
+export function parseSnippet(snippet) {
+    return new SnippetParser(snippet).parse();
+}
+/* The stops in the order Tab visits them: 1, 2 and on, one per index, then the final stop `$0`, which the end of the text stands in for. */
+export function tabOrder(parsed) {
+    const first = new Map();
+    for (const stop of parsed.stops) {
+        const known = first.get(stop.index);
+        if (known === undefined || stop.start < known.start) {
+            first.set(stop.index, stop);
+        }
+    }
+    const visited = [...first.values()].filter((stop) => stop.index > 0).sort((left, right) => left.index - right.index);
+    const final = first.get(0) ?? { index: 0, start: parsed.text.length, end: parsed.text.length };
+    return [...visited, final];
+}

package/dist/symbol-links.d.ts

@@ -0,0 +1,6 @@
+import type { Location, WorkspaceSymbolResult } from '@adecore/lsp';
+export declare const SYMBOL_LINK_CLASS = "cursor-pointer hover:text-accent hover:underline";
+export declare function isTypeName(name: string): boolean;
+export declare function linkTypeNames(html: string): string;
+export declare function declaredNameOf(code: string): string | null;
+export declare function placesOfName(result: WorkspaceSymbolResult, name: string, fileText: string): Location[];

package/dist/symbol-links.js

@@ -0,0 +1,50 @@
+/* The classes a name in a signature has: a pointer and an underline on hover, and the accent only then, so the signature stays calm. */
+export const SYMBOL_LINK_CLASS = 'cursor-pointer hover:text-accent hover:underline';
+/* A name that reads as a type: it starts with a capital and has a lowercase letter, which leaves `DEFAULT_WEIGHTS` and `T` alone. */
+const TYPE_NAME = /^[A-Z][A-Za-z0-9_]*$/;
+export function isTypeName(name) {
+    return TYPE_NAME.test(name) && /[a-z]/.test(name);
+}
+/*
+ * Marks the type-like names of a highlighted snippet as links. Shiki writes each token as a span of its own,
+ * so a name that is the whole text of a token is one; a string or a comment is never that.
+ */
+export function linkTypeNames(html) {
+    return html.replace(/>([A-Z][A-Za-z0-9_]*)</g, (match, name) => isTypeName(name) ? `><span data-symbol="${name}" class="${SYMBOL_LINK_CLASS}">${name}</span><` : match);
+}
+const DECLARES = /\b(?:class|interface|enum|trait|type|namespace|struct|function|const|let|var)\s+&?([A-Za-z_$][\w$]*)/;
+/* The name a signature declares, such as `IssueTicketsMessage` in `final class IssueTicketsMessage implements MessageInterface`; null for one that declares nothing, such as a method of a class. */
+export function declaredNameOf(code) {
+    return DECLARES.exec(code)?.[1] ?? null;
+}
+/* What a workspace symbol is that a type name can mean. */
+const TYPE_KINDS = new Set([2, 3, 5, 10, 11, 23, 26]);
+/*
+ * The places a type name leads to among the symbols a server found for it. Only symbols of exactly that name
+ * count, those that are types ahead of the rest, and when several are left the ones whose container (a
+ * namespace) the current file names, which is how a file says which `Message` it means.
+ */
+export function placesOfName(result, name, fileText) {
+    const found = (result ?? []).filter((symbol) => symbol.name === name);
+    const types = found.filter((symbol) => TYPE_KINDS.has(symbol.kind));
+    let candidates = types.length > 0 ? types : found;
+    if (candidates.length > 1) {
+        const named = candidates.filter((symbol) => symbol.containerName !== undefined && symbol.containerName !== '' && fileText.includes(symbol.containerName));
+        if (named.length > 0) {
+            candidates = named;
+        }
+    }
+    const seen = new Set();
+    return candidates
+        .map((symbol) => 'range' in symbol.location
+        ? symbol.location
+        : { uri: symbol.location.uri, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } } })
+        .filter((location) => {
+        const key = `${location.uri}\0${location.range.start.line}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}