@adecore/editor-react 0.42.0 → 0.43.0

package/dist/editor-language.js

@@ -1,4 +1,8 @@
 import { KEYMAP } from '@adecore/editor/keymap';
+import { DocumentColorsFeature } from './document-colors.js';
+import { DocumentLinksFeature } from './document-links.js';
+import { InlineCompletionFeature } from './inline-completion.js';
+import { LinkedEditingFeature } from './linked-editing.js';
 import { CallHierarchyFeature } from './call-hierarchy.js';
 import { CodeActionsFeature } from './code-actions.js';
 import { CodeVisionFeature } from './code-vision.js';
@@ -12,7 +16,9 @@ import { HighlightsFeature } from './highlights.js';
 import { HistoryFeature } from './history.js';
 import { HoverFeature } from './hover.js';
 import { KeyDispatcher } from './key-priority.js';
+import { MarkupFeature } from './markup.js';
 import { NavigationFeature, locationRow } from './navigation.js';
+import { PasteHistoryFeature } from './paste-history.js';
 import { PeekFeature } from './peek.js';
 import { PickFeature } from './pick.js';
 import { SymbolPickerFeature } from './symbol-picker.js';
@@ -27,6 +33,8 @@ import { SemanticTokensFeature } from './semantic-tokens.js';
 import { SignatureFeature } from './signature.js';
 import { SnippetFeature } from './snippet-session.js';
 import { SymbolsFeature } from './symbols.js';
+/* How long the edits servers want before a save are waited for. */
+const SAVE_PARTICIPANT_MS = 1_000;
 /*
  * The one place that connects an editor to the language servers: it opens the file's document for
  * the editor and lets go of it again. Every language feature of the editor hangs off this object.
@@ -39,6 +47,8 @@ export class EditorLanguage {
   project;
   document;
   languageId;
+  /* Whether a server serves this document; read it where a host meant "a language server is behind this editor". */
+  served;
   /* What the features of this editor have open over it: the hover card, the suggestions, the signature. */
   popups = createPopupStore();
   diagnostics;
@@ -47,6 +57,7 @@ export class EditorLanguage {
   completion;
   signature;
   snippets;
+  markup;
   highlights;
   pick;
   codeActions;
@@ -62,8 +73,14 @@ export class EditorLanguage {
   codeVision;
   formatOnType;
   renderedDocs;
+  pasteHistory;
+  links;
+  colors;
+  linkedEditing;
+  inlineCompletion;
   disposers = [];
   keys = new KeyDispatcher();
+  timers;
   disposed = false;
   constructor(project, editor, uri, languageId, timers = realTimers, options = {}) {
     this.editor = editor;
@@ -72,13 +89,18 @@ export class EditorLanguage {
     this.shortcuts = shortcutsOf(this.keymap, this.apple);
     this.project = project;
     this.languageId = languageId;
-    this.document = project.acquire(uri, languageId, editor);
+    this.served = options.serve ?? true;
+    this.document = project.acquire(uri, languageId, editor, {
+      serve: this.served
+    });
+    this.timers = timers;
     this.onDispose(editor.onKeyDown(event => this.keys.dispatch(event)));
     this.pick = new PickFeature(this, timers);
     this.diagnostics = new DiagnosticsFeature(this);
     this.hover = new HoverFeature(this, timers);
     this.completion = new CompletionFeature(this, timers);
     this.snippets = new SnippetFeature(this, timers);
+    this.markup = new MarkupFeature(this);
     this.signature = new SignatureFeature(this, timers);
     this.highlights = new HighlightsFeature(this, timers);
     this.symbols = new SymbolsFeature(this, timers);
@@ -87,6 +109,11 @@ export class EditorLanguage {
     this.inlayHints = new InlayHintsFeature(this, timers);
     this.codeActions = new CodeActionsFeature(this, timers);
     this.rename = new RenameFeature(this);
+    // Before navigation, whose Mod+click goes to a definition: a link under the pointer goes first.
+    this.links = new DocumentLinksFeature(this, timers);
+    this.colors = new DocumentColorsFeature(this, timers);
+    this.linkedEditing = new LinkedEditingFeature(this, timers);
+    this.inlineCompletion = new InlineCompletionFeature(this, timers);
     this.navigation = new NavigationFeature(this);
     this.peek = new PeekFeature(this, timers);
     this.callHierarchy = new CallHierarchyFeature(this, timers);
@@ -97,13 +124,26 @@ export class EditorLanguage {
     this.codeVision = new CodeVisionFeature(this, listener => this.symbols.onResult(listener), timers);
     this.formatOnType = new FormatOnTypeFeature(this);
     this.renderedDocs = new RenderedDocsFeature(this, timers);
+    this.pasteHistory = new PasteHistoryFeature(this);
     new FoldingFeature(this, listener => this.symbols.onResult(listener), timers);
+    const copies = editor.onCopy?.(copy => project.clipboard.add(copy.text, {
+      wholeLines: copy.wholeLines
+    }));
+    if (copies !== undefined) {
+      this.onDispose(copies);
+    }
+    editor.setWordSources?.(() => this.otherTexts());
+    this.onDispose(() => editor.setWordSources?.(null));
     this.placeOpenedCaret(editor.getCaret());
     this.onDispose(editor.onCaret(position => this.placeOpenedCaret(position)));
   }
   get uri() {
     return this.document.uri;
   }
+  /* The service this document is asked through: the project's, or one that answers nothing when no server serves it. */
+  get service() {
+    return this.document.service;
+  }
   get isDisposed() {
     return this.disposed;
   }
@@ -169,7 +209,7 @@ export class EditorLanguage {
         listener();
       }
     }, () => undefined);
-    const providers = this.project.service.onProvidersChanged(uri => {
+    const providers = this.service.onProvidersChanged(uri => {
       if (uri === this.uri) {
         listener();
       }
@@ -186,6 +226,37 @@ export class EditorLanguage {
   onKey(handler, priority = 0) {
     return this.keys.add(handler, priority);
   }
+  /*
+   * Lets the servers in before the host writes the file: tells them a save is coming and applies the edits they
+   * want made first, such as organized imports. A server that has not answered within a second is passed over,
+   * as the specification allows. Call it, then save, then let the service send `didSave`.
+   */
+  async prepareSave(reason = 1) {
+    const {
+      service
+    } = this.project;
+    await service.willSave?.(this.uri, reason).catch(() => undefined);
+    if (service.willSaveWaitUntil === undefined) {
+      return;
+    }
+    const controller = new AbortController();
+    const timer = this.timers.set(() => controller.abort(), SAVE_PARTICIPANT_MS);
+    try {
+      const edits = await service.willSaveWaitUntil(this.uri, reason, {
+        signal: controller.signal
+      });
+      if (!controller.signal.aborted && edits !== null && edits.length > 0) {
+        this.editor.applyEdits(edits.map(edit => ({
+          range: edit.range,
+          text: edit.newText
+        })));
+      }
+    } catch {
+      // A server that fails or is too slow does not keep the file from being saved.
+    } finally {
+      this.timers.clear(timer);
+    }
+  }
   /* Runs `dispose` when the editor lets go of its document. */
   onDispose(dispose) {
     this.disposers.push(dispose);
@@ -200,6 +271,10 @@ export class EditorLanguage {
     }
     this.document.release();
   }
+  /* The texts of the other open editors of the project, which Hippie completion takes words from. */
+  otherTexts() {
+    return this.project.openEditors().filter(open => open.uri !== this.uri).map(open => open.editor.getText());
+  }
   /* A file opened from another one lands on the line; this puts the caret on the column the jump meant. */
   placeOpenedCaret(position) {
     const column = this.project.takeCaret(this.uri, position.line);

package/dist/emmet.d.ts

@@ -0,0 +1,13 @@
+import type { MarkupSyntax } from './markup-context.ts';
+export interface AbbreviationOptions {
+    readonly syntax: MarkupSyntax;
+    readonly indent: string;
+    readonly wrap?: readonly string[];
+}
+export interface FoundAbbreviation {
+    readonly abbreviation: string;
+    readonly start: number;
+    readonly end: number;
+}
+export declare function abbreviationBefore(line: string, character: number): FoundAbbreviation | null;
+export declare function expandAbbreviation(abbreviation: string, options: AbbreviationOptions): string | null;

package/dist/emmet.js

@@ -0,0 +1,62 @@
+// A reference and no import, so an app that type-checks this source reads the declaration of the package too.
+// oxlint-disable-next-line typescript/triple-slash-reference
+/// <reference path="./emmet-module.d.ts" />
+import { extract, markup, markupAbbreviation, resolveConfig } from 'emmet';
+/* A text of an expansion is snippet syntax, where these mean a tab stop or end one. */
+function escapeText(text) {
+  return text.replace(/[$}\\]/g, '\\$&');
+}
+function field(index, placeholder) {
+  return placeholder === '' ? `\${${index}}` : `\${${index}:${escapeText(placeholder)}}`;
+}
+/* `lipsum` is the other name of `lorem` that IntelliJ and the Emmet documentation accept. */
+function renameLipsum(node) {
+  if (node.name !== undefined && /^lipsum(?=\d|$)/i.test(node.name)) {
+    node.name = 'lorem' + node.name.slice(6);
+  }
+  for (const child of node.children) {
+    renameLipsum(child);
+  }
+}
+/* The abbreviation that ends at `character` of a line, or null where nothing before the caret reads as one. */
+export function abbreviationBefore(line, character) {
+  const found = extract(line, character, {
+    type: 'markup',
+    lookAhead: true
+  });
+  if (found === undefined || !/^[A-Za-z!.#([{]/.test(found.abbreviation)) {
+    return null;
+  }
+  return {
+    abbreviation: found.abbreviation,
+    start: found.start,
+    end: found.end
+  };
+}
+/*
+ * The expansion of an abbreviation as snippet text, its places to fill as tab stops; null when it does not
+ * read as one. Lorem ipsum words after the first sentence differ per expansion.
+ */
+export function expandAbbreviation(abbreviation, options) {
+  const text = options.wrap === undefined ? undefined : [...options.wrap];
+  try {
+    const tree = markupAbbreviation(abbreviation, {
+      text
+    });
+    for (const child of tree.children) {
+      renameLipsum(child);
+    }
+    const expanded = markup(tree, resolveConfig({
+      syntax: options.syntax === 'xml' ? 'xml' : 'html',
+      text,
+      options: {
+        'output.field': field,
+        'output.text': escapeText,
+        'output.indent': options.indent
+      }
+    }));
+    return expanded === '' ? null : expanded;
+  } catch {
+    return null;
+  }
+}

package/dist/folding.js

@@ -60,14 +60,13 @@ export class FoldingFeature {
     this.language = language;
     const {
       editor,
-      project,
       uri
     } = language;
     this.refresher = new Refresher(async signal => {
-      if (!project.service.supports(METHOD, uri)) {
+      if (!language.service.supports(METHOD, uri)) {
         return;
       }
-      const ranges = await project.service.foldingRanges(uri, {
+      const ranges = await language.service.foldingRanges(uri, {
         signal
       });
       if (!signal.aborted) {

package/dist/format-on-type.js

@@ -38,10 +38,9 @@ export class FormatOnTypeFeature {
   /* Whether the server of this document formats on type and the service can ask it. */
   get supported() {
     const {
-      project,
       uri
     } = this.language;
-    return project.service.onTypeFormatting !== undefined && project.service.supports(METHOD, uri);
+    return this.language.service.onTypeFormatting !== undefined && this.language.service.supports(METHOD, uri);
   }
   configure(enabled) {
     this.enabled = enabled;
@@ -51,7 +50,7 @@ export class FormatOnTypeFeature {
   }
   /* The characters that ask the server, the first one and the more. */
   triggerCharacters() {
-    const options = this.language.project.service.providerOptions(METHOD, this.language.uri);
+    const options = this.language.service.providerOptions(METHOD, this.language.uri);
     return options === undefined ? [] : [...(options.firstTriggerCharacter === undefined ? [] : [options.firstTriggerCharacter]), ...(options.moreTriggerCharacter ?? [])];
   }
   typed(change) {
@@ -80,14 +79,13 @@ export class FormatOnTypeFeature {
   async ask(revision, typed, caret, signal) {
     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, {
+      const edits = await this.language.service.onTypeFormatting(uri, caret, typed, {
         ...editor.getIndentation()
       }, {
         signal

package/dist/highlights.js

@@ -40,15 +40,14 @@ export class HighlightsFeature {
     this.language = language;
     const {
       editor,
-      project,
       uri
     } = language;
     this.refresher = new Refresher(async signal => {
-      if (!project.service.supports(METHOD, uri) || !this.onName()) {
+      if (!language.service.supports(METHOD, uri) || !this.onName()) {
         this.clear();
         return;
       }
-      const result = await project.service.documentHighlights(uri, editor.getCaret(), {
+      const result = await language.service.documentHighlights(uri, editor.getCaret(), {
         signal
       });
       if (!signal.aborted) {

package/dist/history.d.ts

@@ -1,9 +1,16 @@
 import type { EditorLanguage } from './editor-language.ts';
 export declare class HistoryFeature {
     private readonly language;
+    private editing;
     constructor(language: EditorLanguage);
+    lastEdit(): boolean;
+    nextEdit(): boolean;
     back(): boolean;
     forward(): boolean;
     recent(): void;
+    private currentEdit;
+    private edited;
+    private moved;
+    private visitEdit;
     private visit;
 }

package/dist/history.js

@@ -3,6 +3,7 @@ import { isShortcut } from './shortcut-keys.js';
 /* Back, Forward and the list of recent locations over the history the whole project shares. */
 export class HistoryFeature {
   language;
+  editing = false;
   constructor(language) {
     this.language = language;
     const off = language.onKey(event => {
@@ -18,9 +19,37 @@ export class HistoryFeature {
         this.recent();
         return true;
       }
+      if (isShortcut(this.language.shortcuts.lastEditLocation, event)) {
+        this.lastEdit();
+        return true;
+      }
+      if (isShortcut(this.language.shortcuts.nextEditLocation, event)) {
+        this.nextEdit();
+        return true;
+      }
       return false;
     }, KEY_PRIORITY.history);
-    language.onDispose(off);
+    // A jump of the editor's own, such as Method Down, is a place Back returns to like any other jump.
+    const navigations = language.editor.onNavigate?.(from => language.project.history.record({
+      uri: language.uri,
+      position: from
+    }));
+    const changes = language.editor.onTextChange(change => this.edited(change));
+    const carets = language.editor.onCaret(position => this.moved(position));
+    language.onDispose(() => {
+      off();
+      navigations?.();
+      changes();
+      carets();
+    });
+  }
+  /* Goes to where the project was edited before the carets' place; false when there is no such place. */
+  lastEdit() {
+    return this.visitEdit(this.language.project.edits.previous(this.currentEdit()));
+  }
+  /* Goes to where the project was edited after the place Last Edit Location came back to. */
+  nextEdit() {
+    return this.visitEdit(this.language.project.edits.next(this.currentEdit()));
   }
   /* Returns to where the caret was before the last jump; false when there is no such place. */
   back() {
@@ -40,6 +69,55 @@ export class HistoryFeature {
       }
     })), this.language.editor.getCaret(), this.language.project.i18n.t('editor:language.history.recent'));
   }
+  currentEdit() {
+    return {
+      uri: this.language.uri,
+      selections: this.language.editor.getSelections()
+    };
+  }
+  /* Every edit moves the places of the file; one a person made counts as an edit location once the caret has settled. */
+  edited(change) {
+    const {
+      editor,
+      project,
+      uri
+    } = this.language;
+    project.edits.map(uri, change.changes);
+    this.editing = true;
+    queueMicrotask(() => {
+      this.editing = false;
+      if (change.source !== 'external' && editor.hasFocus?.() !== false && !this.language.isDisposed) {
+        project.edits.record(this.currentEdit());
+      }
+    });
+  }
+  /* A caret that moves on its own ends the walk through the edits, unless an edit moved it. */
+  moved(position) {
+    if (!this.editing) {
+      this.language.project.edits.moved(this.language.uri, position);
+    }
+  }
+  visitEdit(place) {
+    if (place === null) {
+      return false;
+    }
+    const {
+      editor,
+      project,
+      uri
+    } = this.language;
+    if (place.uri === uri) {
+      editor.setSelections(place.selections, 'center');
+      editor.focus();
+    } else {
+      // Another file opens on one caret, the primary.
+      project.openPlace({
+        uri: place.uri,
+        position: place.selections.at(-1).end
+      });
+    }
+    return true;
+  }
   visit(place) {
     if (place === null) {
       return false;

package/dist/host-types.d.ts

@@ -2,9 +2,11 @@ import type { WorkerRequestPort } from '@adecore/editor/worker-client';
 import type { EditorPosition, EditorRange } from '@adecore/editor';
 import type { i18n } from 'i18next';
 import type { Keymap } from '@adecore/editor/keymap';
+import type { ClipboardHistory } from './clipboard-history.ts';
 import type { ProjectFiles } from './workspace-edit.ts';
 import type { Place } from './navigation-history.ts';
 import type { ProblemSource } from './project-problems.ts';
+import type { ServerMessage } from '@adecore/lsp';
 export interface DiskText {
     text: string;
     mtime: number;
@@ -55,13 +57,17 @@ export interface LanguageHost {
     readonly files?: ProjectFiles;
     readonly apple?: boolean;
     readonly keymap?: Keymap;
+    readonly clipboard?: ClipboardHistory;
+    readonly editHistoryLimit?: number;
     readonly panelBodyHeight?: number;
     onPanelResize?(height: number): void;
     readonly problemSource?: ProblemSource;
     openPlace?(place: Place): void;
+    openExternal?(url: string): void;
     pathOfUri?(uri: string): string | null;
     serverNames?(uri: string): readonly string[];
     notify?(notification: EditorNotification): void;
+    onServerMessage?(message: ServerMessage): void;
     resolveSnippetVariable?(name: string, context: SnippetVariableContext): string | undefined;
     suggestNames?(request: RenameSuggestionsRequest, signal: AbortSignal): Promise<readonly string[]>;
 }

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { KEY_PRIORITY } from './key-priority.ts';
 export { realTimers, type Timers } from './timers.ts';
 export { type SemanticTokensOptions } from './semantic-tokens.ts';
 export { ProjectLanguage, type FileOperationTarget } from './project-language.ts';
-export type { LanguageDocumentHandle } from './project-language.ts';
+export type { AcquireOptions, LanguageDocumentHandle } from './project-language.ts';
 export type { SnippetVariableContext, LanguageHost, DiskText, GitBlameCommit, GitBlameResult, EditorNotification, RenameSuggestionsRequest } from './host-types.ts';
 export { EditorView } from './EditorView.tsx';
 export { createHolder } from './holder.ts';
@@ -13,6 +13,10 @@ export type { LanguagePopupsProps } from './LanguagePopups.tsx';
 export { AnchoredPopup } from './AnchoredPopup.tsx';
 export { SignatureCard } from './SignatureCard.tsx';
 export { type RenderedDocsFeature } from './rendered-docs.ts';
+export { type DocumentLinksFeature } from './document-links.ts';
+export { type DocumentColorsFeature } from './document-colors.ts';
+export { type LinkedEditingFeature } from './linked-editing.ts';
+export { type InlineCompletionFeature, type InlineSuggestion } from './inline-completion.ts';
 export type { RenderedDocEntry, RenderedDocsSettings } from './rendered-docs.ts';
 export type { DocTagEntry, DocTagSection, ParsedDocComment } from './doc-comment-model.ts';
 export { EditorRenderingProvider } from './rendering.tsx';
@@ -28,12 +32,17 @@ export { useProblemCounts } from './use-problem-counts.ts';
 export type { ProblemCounts } from './diagnostics.ts';
 export type { BlameSource, CodeVisionSettings } from './code-vision.ts';
 export type { HoverSettings } from './hover.ts';
-export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, CallHierarchyView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView } from './popups.ts';
+export type { PopupState, PopupStore, HoverInfo, HoverView, CompletionView, CompletionDocs, CompletionRow, SignatureView, RenameView, RenameFileView, PeekView, CallHierarchyView, PickView, PickGroup, PickRow, PickPreview, SymbolsView, MenuView, AuthorsView, WrapView } from './popups.ts';
+export { type MarkupFeature } from './markup.ts';
+export type { MarkupSettings } from './markup.ts';
 export { RowHost, LineActionHost } from './row-host.ts';
 export type { HostedRow, HostedAction } from './row-host.ts';
 export { type HighlightLayers, highlightLayers } from './highlight-layers.ts';
 export { type NavigationHistory } from './navigation-history.ts';
 export type { Place } from './navigation-history.ts';
+export { EditLocations, type EditPlace } from './edit-locations.ts';
+export { ClipboardHistory, type ClipboardEntry, type ClipboardHistoryOptions } from './clipboard-history.ts';
+export { type PasteHistoryFeature } from './paste-history.ts';
 export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFrom } from './view-state.ts';
 export type { ViewState, RevealLineRequest } from './view-state.ts';
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.ts';

package/dist/index.js

@@ -9,15 +9,23 @@ export { LanguagePopups } from "./LanguagePopups.js";
 export { AnchoredPopup } from "./AnchoredPopup.js";
 export { SignatureCard } from "./SignatureCard.js";
 export {} from './rendered-docs.js';
+export {} from './document-links.js';
+export {} from './document-colors.js';
+export {} from './linked-editing.js';
+export {} from './inline-completion.js';
 export { EditorRenderingProvider } from "./rendering.js";
 export { FindReplace } from "./FindReplace.js";
 export { ChangeReview } from "./ChangeReview.js";
 export { ProjectProblems, serviceProblems, countsOf } from './project-problems.js';
 export { applyWorkspaceEdit, supportedResourceOperations } from './workspace-edit.js';
 export { useProblemCounts } from './use-problem-counts.js';
+export {} from './markup.js';
 export { RowHost, LineActionHost } from './row-host.js';
 export { highlightLayers } from './highlight-layers.js';
 export {} from './navigation-history.js';
+export { EditLocations } from './edit-locations.js';
+export { ClipboardHistory } from './clipboard-history.js';
+export {} from './paste-history.js';
 export { openingPlace, viewStates, followViewStates, viewStateKey, forgetMovesFrom } from './view-state.js';
 export { lspLanguageIdOf, shikiLanguageOf, shikiLanguageOfPath } from './language-ids.js';
 export { AttributionCard } from "./AttributionCard.js";

package/dist/inlay-hints.js

@@ -321,7 +321,7 @@ export class InlayHintsFeature {
   }
   /* Whether asking the server could still change what the hint offers. */
   resolvable(entry) {
-    return !entry.answered && entry.epoch === this.epoch && this.language.project.service.supports(RESOLVE_METHOD, this.language.uri);
+    return !entry.answered && entry.epoch === this.epoch && this.language.service.supports(RESOLVE_METHOD, this.language.uri);
   }
   /* Underlines the part under the pointer when a press would do something with it: a command always, a place while the key is down. */
   updateLink() {
@@ -398,7 +398,7 @@ export class InlayHintsFeature {
         this.cancelHover();
         this.language.goTo(action.location);
       } else if (action.kind === 'run') {
-        await project.service.executeCommand(uri, action.command);
+        await this.language.service.executeCommand(uri, action.command);
       } else if (entry.epoch === this.epoch && editsFit(editor, action.edits)) {
         this.cancelHover();
         const applied = editor.applyEdits(action.edits.map(edit => ({

package/dist/inline-completion.d.ts

@@ -0,0 +1,39 @@
+import type { EditorPosition } from '@adecore/editor';
+import type { InlineCompletionItem, InlineCompletionResult, Range } from '@adecore/lsp';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export interface InlineSuggestion {
+    readonly item: InlineCompletionItem;
+    readonly text: string;
+    readonly range: Range;
+    readonly rest: string;
+}
+export declare function itemsOf(result: InlineCompletionResult): InlineCompletionItem[];
+export declare function suggestionOf(item: InlineCompletionItem, caret: EditorPosition, textOf: (range: Range) => string): InlineSuggestion | null;
+export declare class InlineCompletionFeature {
+    private readonly language;
+    private readonly timers;
+    private enabled;
+    private suggestions;
+    private index;
+    private timer;
+    private controller;
+    private revision;
+    private accepting;
+    constructor(language: EditorLanguage, timers?: Timers);
+    get supported(): boolean;
+    get isEnabled(): boolean;
+    get current(): InlineSuggestion | null;
+    configure(settings: {
+        readonly enabled?: boolean;
+    }): void;
+    trigger(): void;
+    accept(): boolean;
+    cycle(step: 1 | -1): void;
+    hide(): void;
+    private key;
+    private edited;
+    private moved;
+    private ask;
+    private draw;
+}