@adecore/editor-react 0.42.0 → 0.44.0

package/dist/project-language.js

@@ -1,11 +1,15 @@
 import { disposeSnippetTransforms } from './snippet-transform-queue.js';
 import i18next from 'i18next';
-import { fileUriToPath, pathToFileUri } from '@adecore/lsp';
+import { fileUriToPath, pathToFileUri, unservedLanguageService } from '@adecore/lsp';
+import { ClipboardHistory } from './clipboard-history.js';
+import { TemplateRegistry } from './templates.js';
+import { EditLocations } from './edit-locations.js';
 import { NavigationHistory } from './navigation-history.js';
 import { ProjectProblems, serviceProblems } from './project-problems.js';
 import { applyWorkspaceEdit } from './workspace-edit.js';
 import { relativeTo } from './paths.js';
 import { PANEL_BODY_HEIGHT } from './panel-size.js';
+const UNSERVED = unservedLanguageService();
 /* Sends one editor's edits to the document, holding them until the document is open. */
 class DocumentSync {
   ready;
@@ -86,6 +90,9 @@ export class ProjectLanguage {
   folder;
   problems;
   history = new NavigationHistory();
+  edits;
+  clipboard;
+  templates;
   holders = new Map();
   files;
   /* The body height of the peek and call hierarchy panels, shared by the editors of the project. */
@@ -94,14 +101,23 @@ export class ProjectLanguage {
   pendingCaret = null;
   lastPlace = null;
   disposed = false;
+  subscriptions;
+  /* The result id the server gave each document in its last workspace report, which the next asks with. */
+  workspaceResults = new Map();
   constructor(service, host = {}) {
     this.service = service;
     this.host = host;
     this.i18n = host.i18n ?? i18next;
     this.folder = host.folder ?? '';
     this.files = host.files ?? null;
+    this.edits = new EditLocations(host.editHistoryLimit);
+    this.clipboard = host.clipboard ?? new ClipboardHistory();
+    this.templates = host.templates ?? new TemplateRegistry();
     this.panelBodyHeight = host.panelBodyHeight ?? PANEL_BODY_HEIGHT;
     this.problems = new ProjectProblems(host.problemSource ?? serviceProblems(service, uri => this.pathOfLocation(uri) ?? uri));
+    const shows = service.onShowDocument?.(params => this.showDocument(params));
+    const messages = host.onServerMessage === undefined ? undefined : service.onServerMessage?.(message => host.onServerMessage(message));
+    this.subscriptions = [shows, messages].flatMap(subscription => subscription === undefined ? [] : [subscription]);
   }
   /* Open panels of other editors of the project follow a resize. */
   onPanelBodyChange(listener) {
@@ -153,16 +169,86 @@ export class ProjectLanguage {
   }
   /* Tells the servers that files were deleted, once they are. */
   didDeleteFiles(targets) {
-    return this.service.didDeleteFiles?.(filesOf(targets)) ?? Promise.resolve();
+    const files = filesOf(targets);
+    this.edits.forget(uri => files.some(file => file.directory ? uri.startsWith(`${file.uri}/`) : uri === file.uri));
+    return this.service.didDeleteFiles?.(files) ?? Promise.resolve();
   }
-  /* The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no text file. */
+  /*
+   * The text of a file as it stands now: an open document's, else a draft's or the machine's; null when it is no
+   * text file. A document of a scheme a server owns, such as a decompiled class, is read from that server.
+   */
   async readText(uri) {
-    const open = this.holders.get(uri)?.sync.text;
+    const open = this.holders.get(uri)?.editors[0]?.getText();
     if (open !== undefined) {
       return open;
     }
     const path = fileUriToPath(uri);
-    return path === null || this.files === null ? null : (await this.files.read(path))?.text ?? null;
+    if (path === null) {
+      return (await this.service.textDocumentContent?.(uri).catch(() => null)) ?? null;
+    }
+    return this.files === null ? null : (await this.files.read(path))?.text ?? null;
+  }
+  /*
+   * Asks the server of `uri` for the problems of every file it knows and lists them in `problems`, for a server that
+   * offers workspace diagnostics. A file the server reports as unchanged keeps what it had. False when no server offers them.
+   */
+  async pullWorkspaceProblems(uri, options = {}) {
+    const {
+      service
+    } = this;
+    if (service.workspaceDiagnostics === undefined || !service.supports('workspace/diagnostic', uri)) {
+      return false;
+    }
+    const previous = [...this.workspaceResults].map(([key, value]) => ({
+      uri: key,
+      value
+    }));
+    const report = await service.workspaceDiagnostics(uri, previous, options);
+    const server = this.host.serverNames?.(uri)[0] ?? 'workspace';
+    for (const item of report.items) {
+      if (item.resultId !== undefined) {
+        this.workspaceResults.set(item.uri, item.resultId);
+      }
+      if (item.kind === 'full') {
+        this.problems.report(this.pathOfLocation(item.uri) ?? item.uri, server, item.items);
+      }
+    }
+    return true;
+  }
+  /* Shows what a server asks for: a web address outside the editor, anything else as a place of the host. */
+  async showDocument(params) {
+    const web = /^(https?|mailto):/i.test(params.uri);
+    if (params.external === true || web) {
+      if (this.host.openExternal !== undefined) {
+        this.host.openExternal(params.uri);
+        return {
+          success: true
+        };
+      }
+      if (typeof window === 'undefined') {
+        return {
+          success: false
+        };
+      }
+      return {
+        success: window.open(params.uri, '_blank', 'noopener,noreferrer') !== null
+      };
+    }
+    if (this.host.openPlace === undefined) {
+      return {
+        success: false
+      };
+    }
+    this.openPlace({
+      uri: params.uri,
+      position: params.selection?.start ?? {
+        line: 0,
+        character: 0
+      }
+    });
+    return {
+      success: true
+    };
   }
   /*
    * Opens the file of a place on its line. A file opens on a line only, so the column is kept here until the editor
@@ -192,27 +278,40 @@ export class ProjectLanguage {
     this.pendingCaret = null;
     return pending.position;
   }
+  /* The editors that hold a document, one per uri in the order the documents were first opened. */
+  openEditors() {
+    return [...this.holders].flatMap(([uri, holder]) => holder.editors[0] === undefined ? [] : [{
+      uri,
+      editor: holder.editors[0]
+    }]);
+  }
   /* Opens `uri` for the editor, or joins the editors that already hold it. */
-  acquire(uri, languageId, editor) {
+  acquire(uri, languageId, editor, options = {}) {
     if (this.disposed) {
       throw new Error('The project language is disposed');
     }
+    const serve = options.serve ?? true;
     let holder = this.holders.get(uri);
     if (holder === undefined) {
       holder = {
         editors: [],
-        sync: new DocumentSync(this.service, uri, languageId, editor),
+        served: [],
+        sync: null,
         languageId
       };
       this.holders.set(uri, holder);
     }
     holder.editors.push(editor);
+    if (serve) {
+      holder.served.push(editor);
+      holder.sync ??= new DocumentSync(this.service, uri, languageId, editor);
+    }
     let released = false;
     return {
       uri,
-      service: this.service,
+      service: serve ? this.service : UNSERVED,
       get ready() {
-        return holder.sync.ready;
+        return serve ? holder.sync?.ready ?? Promise.resolve() : Promise.resolve();
       },
       release: () => {
         if (!released) {
@@ -228,20 +327,29 @@ export class ProjectLanguage {
       return;
     }
     holder.editors.splice(holder.editors.indexOf(editor), 1);
-    const next = holder.editors[0];
-    if (next === undefined) {
-      holder.sync.dispose();
+    if (holder.served.includes(editor)) {
+      holder.served.splice(holder.served.indexOf(editor), 1);
+    }
+    const {
+      sync
+    } = holder;
+    if (holder.editors.length === 0) {
       this.holders.delete(uri);
-      void holder.sync.ready.catch(() => undefined).then(() => {
-        if (this.holders.has(uri)) {
+    }
+    if (sync === null || sync.editor !== editor) {
+      return;
+    }
+    sync.dispose();
+    const next = holder.served[0];
+    // The editor that sent the changes is gone; the next served one takes over and opens the document with its own text.
+    holder.sync = next === undefined ? null : new DocumentSync(this.service, uri, holder.languageId, next);
+    if (holder.sync === null) {
+      void sync.ready.catch(() => undefined).then(() => {
+        if (this.holders.get(uri)?.sync) {
           return undefined;
         }
         return this.service.closeDocument(uri);
       }).catch(() => undefined);
-    } else if (holder.sync.editor === editor) {
-      // The editor that sent the changes is gone; the next one takes over and opens the document with its own text.
-      holder.sync.dispose();
-      holder.sync = new DocumentSync(this.service, uri, holder.languageId, next);
     }
   }
   dispose() {
@@ -249,8 +357,14 @@ export class ProjectLanguage {
       return;
     }
     this.disposed = true;
+    for (const subscription of this.subscriptions) {
+      subscription.dispose();
+    }
     disposeSnippetTransforms(this);
     for (const [uri, holder] of this.holders) {
+      if (holder.sync === null) {
+        continue;
+      }
       holder.sync.dispose();
       void holder.sync.ready.catch(() => undefined).then(() => this.service.closeDocument(uri)).catch(() => undefined);
     }

package/dist/rename.js

@@ -44,19 +44,18 @@ export class RenameFeature {
   async start() {
     const {
       editor,
-      project,
       uri
     } = this.language;
-    if (!project.service.supports(METHOD, uri)) {
+    if (!this.language.service.supports(METHOD, uri)) {
       this.tell('error', this.say('unavailable'));
       return;
     }
     this.cancel();
     const caret = editor.getCaret();
-    const prepare = project.service.providerOptions(METHOD, uri)?.prepareProvider === true;
+    const prepare = this.language.service.providerOptions(METHOD, uri)?.prepareProvider === true;
     let answer;
     try {
-      answer = prepare ? await project.service.prepareRename(uri, caret) : {
+      answer = prepare ? await this.language.service.prepareRename(uri, caret) : {
         defaultBehavior: true
       };
     } catch (error) {
@@ -110,7 +109,7 @@ export class RenameFeature {
       uri
     } = this.language;
     try {
-      const edit = await project.service.rename(uri, session.target.range.start, next);
+      const edit = await this.language.service.rename(uri, session.target.range.start, next);
       if (this.session !== session) {
         return;
       }
@@ -204,14 +203,13 @@ export class RenameFeature {
   async light(session) {
     const {
       editor,
-      project,
       uri
     } = this.language;
-    if (!project.service.supports('textDocument/references', uri)) {
+    if (!this.language.service.supports('textDocument/references', uri)) {
       return null;
     }
     try {
-      const locations = await project.service.references(uri, session.target.range.start, true);
+      const locations = await this.language.service.references(uri, session.target.range.start, true);
       if (this.session !== session || locations === null) {
         return null;
       }
@@ -282,14 +280,13 @@ export class RenameFeature {
   /* So a suggester knows a function from a variable; a rename on a use finds the kind through the declaration's place in this file. */
   async kindOf(session, locations) {
     const {
-      project,
       uri
     } = this.language;
-    if (!project.service.supports('textDocument/documentSymbol', uri)) {
+    if (!this.language.service.supports('textDocument/documentSymbol', uri)) {
       return undefined;
     }
     try {
-      const symbols = await project.service.documentSymbols(uri, {
+      const symbols = await this.language.service.documentSymbols(uri, {
         signal: session.names.signal,
         parallel: true
       });

package/dist/rendered-docs.js

@@ -192,10 +192,9 @@ export class RenderedDocsFeature {
   /* Whether names in `{@link}` and `@see` can be followed, which takes a server that finds symbols by name. */
   get canFollow() {
     const {
-      project,
       uri
     } = this.language;
-    return project.service.supports('workspace/symbol', uri);
+    return this.language.service.supports('workspace/symbol', uri);
   }
   /* Goes to what a link in a comment names. */
   follow(name, comment) {

package/dist/selection-ranges.js

@@ -15,14 +15,13 @@ export class SelectionRangesFeature {
   constructor(language) {
     const {
       editor,
-      project,
       uri
     } = language;
     editor.setSelectionRanges(async positions => {
-      if (!project.service.supports(METHOD, uri)) {
+      if (!language.service.supports(METHOD, uri)) {
         return null;
       }
-      const chains = await project.service.selectionRanges(uri, positions);
+      const chains = await language.service.selectionRanges(uri, positions);
       return chains === null || chains.length !== positions.length ? null : chains.map(selectionChainOf);
     });
     language.onDispose(() => editor.setSelectionRanges(null));

package/dist/shortcut-keys.d.ts

@@ -12,10 +12,15 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     autoIndentLines: LanguageShortcut | null;
     callHierarchy: LanguageShortcut | null;
     codeActions: LanguageShortcut | null;
+    codeBlockEnd: LanguageShortcut | null;
+    codeBlockEndWithSelection: LanguageShortcut | null;
+    codeBlockStart: LanguageShortcut | null;
+    codeBlockStartWithSelection: LanguageShortcut | null;
     collapse: LanguageShortcut | null;
     collapseAll: LanguageShortcut | null;
     collapseDocComments: LanguageShortcut | null;
     collapseRecursively: LanguageShortcut | null;
+    completeCurrentStatement: LanguageShortcut | null;
     convertIndentsToSpaces: LanguageShortcut | null;
     convertIndentsToTabs: LanguageShortcut | null;
     decreaseFontSize: LanguageShortcut | null;
@@ -41,20 +46,33 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     goToImplementation: LanguageShortcut | null;
     goToSymbol: LanguageShortcut | null;
     goToTypeDefinition: LanguageShortcut | null;
+    hippieBackwardCompletion: LanguageShortcut | null;
+    hippieCompletion: LanguageShortcut | null;
     historyBack: LanguageShortcut | null;
     historyForward: LanguageShortcut | null;
     increaseFontSize: LanguageShortcut | null;
     inlineEdit: LanguageShortcut | null;
+    insertLiveTemplate: LanguageShortcut | null;
     joinLines: LanguageShortcut | null;
+    lastEditLocation: LanguageShortcut | null;
     matchBrace: LanguageShortcut | null;
+    methodDown: LanguageShortcut | null;
+    methodUp: LanguageShortcut | null;
     moveLineDown: LanguageShortcut | null;
     moveLineUp: LanguageShortcut | null;
+    moveStatementDown: LanguageShortcut | null;
+    moveStatementUp: LanguageShortcut | null;
+    nextChange: LanguageShortcut | null;
+    nextEditLocation: LanguageShortcut | null;
     nextHighlight: LanguageShortcut | null;
     nextProblem: LanguageShortcut | null;
     organizeImports: LanguageShortcut | null;
     parameterInfo: LanguageShortcut | null;
+    pasteAsPlainText: LanguageShortcut | null;
+    pasteFromHistory: LanguageShortcut | null;
     peekDefinition: LanguageShortcut | null;
     peekReferences: LanguageShortcut | null;
+    previousChange: LanguageShortcut | null;
     previousHighlight: LanguageShortcut | null;
     previousProblem: LanguageShortcut | null;
     quickInfo: LanguageShortcut | null;
@@ -66,6 +84,7 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     resetFontSize: LanguageShortcut | null;
     reverseLines: LanguageShortcut | null;
     save: LanguageShortcut | null;
+    saveAsLiveTemplate: LanguageShortcut | null;
     selectAll: LanguageShortcut | null;
     selectAllOccurrences: LanguageShortcut | null;
     selectNextOccurrence: LanguageShortcut | null;
@@ -84,6 +103,8 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     startNewLine: LanguageShortcut | null;
     startNewLineBefore: LanguageShortcut | null;
     suggestInline: LanguageShortcut | null;
+    surroundWith: LanguageShortcut | null;
+    surroundWithLiveTemplate: LanguageShortcut | null;
     textEnd: LanguageShortcut | null;
     textStart: LanguageShortcut | null;
     toggleBlockComment: LanguageShortcut | null;
@@ -92,10 +113,13 @@ export declare function shortcutsOf(keymap: Keymap, apple: boolean): {
     toggleLineComment: LanguageShortcut | null;
     toggleRenderedDocs: LanguageShortcut | null;
     triggerCompletion: LanguageShortcut | null;
+    typeHierarchy: LanguageShortcut | null;
     undo: LanguageShortcut | null;
     uniqueLines: LanguageShortcut | null;
     unselectOccurrence: LanguageShortcut | null;
+    unwrap: LanguageShortcut | null;
     wordLeft: LanguageShortcut | null;
     wordRight: LanguageShortcut | null;
+    wrapWithAbbreviation: LanguageShortcut | null;
 };
 export declare function isShortcut(target: LanguageShortcut | null, event: KeyboardEvent): boolean;

package/dist/signature.js

@@ -102,10 +102,9 @@ export class SignatureFeature {
   }
   options() {
     const {
-      project,
       uri
     } = this.language;
-    const options = project.service.providerOptions(METHOD, uri);
+    const options = this.language.service.providerOptions(METHOD, uri);
     return options === undefined ? null : {
       triggers: options.triggerCharacters ?? [],
       retriggers: options.retriggerCharacters ?? []
@@ -145,10 +144,9 @@ export class SignatureFeature {
   }
   ask(context) {
     const {
-      project,
       uri
     } = this.language;
-    if (!project.service.supports(METHOD, uri)) {
+    if (!this.language.service.supports(METHOD, uri)) {
       return;
     }
     this.timers.clear(this.timer);
@@ -164,7 +162,6 @@ export class SignatureFeature {
   async fetch(context, request) {
     const {
       editor,
-      project,
       uri
     } = this.language;
     const caret = editor.getCaret();
@@ -173,7 +170,7 @@ export class SignatureFeature {
     this.controller = controller;
     let help;
     try {
-      help = await project.service.signatureHelp(uri, caret, context, {
+      help = await this.language.service.signatureHelp(uri, caret, context, {
         signal: controller.signal
       });
     } catch {

package/dist/snippet-insert.d.ts

@@ -0,0 +1,10 @@
+import type { Editor, EditorRange } from '@adecore/editor';
+import type { EditorLanguage } from './editor-language.ts';
+export interface SnippetPlacement {
+    readonly range: EditorRange;
+    readonly selectedText?: string;
+}
+export declare function bodyWithIndentUnit(body: string, unit: string): string;
+export declare function indentUnitOf(editor: Editor): string;
+export declare function dedentLines(text: string, base?: string): string;
+export declare function insertSnippet(language: EditorLanguage, source: string, placements: readonly SnippetPlacement[], extra?: (name: string) => string | undefined): Promise<boolean>;

package/dist/snippet-insert.js

@@ -0,0 +1,217 @@
+import { SnippetTransformQueueError } from './snippet-transform-queue.js';
+import { comparePositions, shiftPosition } from './diagnostics-model.js';
+import { lineTextOf, textBeforeOf } from './line-text.js';
+import { wordRangeAt } from './rename-model.js';
+import { jobTable } from './snippet-field-transforms.js';
+import { indentSnippet } from './snippet-indent.js';
+import { positionInInsertion } from './snippet-session.js';
+import { SnippetTransformError } from './snippet-transform-client.js';
+import { MAX_TRANSFORM_JOBS, MAX_TRANSFORM_WORK } from './snippet-transform-protocol.js';
+import { compileSnippet, tabOrder } from './snippet.js';
+import { createSnippetResolver } from './snippet-variables.js';
+import { fileUriToPath } from '@adecore/lsp';
+/* The same limits as an inserted completion item. */
+const MAX_CHARACTERS = 2_000_000;
+const MAX_RANGES = 1_000;
+const TOAST_ID = 'language-completion';
+class LimitError extends Error {}
+/* Each line's leading tabs become the editor's own indentation unit. */
+export function bodyWithIndentUnit(body, unit) {
+  return unit === '\t' ? body : body.replace(/^\t+/gm, tabs => unit.repeat(tabs.length));
+}
+/* One level of the editor's indentation: spaces for a tab size, or a tab. */
+export function indentUnitOf(editor) {
+  const {
+    tabSize,
+    insertSpaces
+  } = editor.getIndentation();
+  return insertSpaces ? ' '.repeat(tabSize) : '\t';
+}
+/* The lines after the first without `base` in front of them, or without the shortest indentation among them. */
+export function dedentLines(text, base) {
+  const lines = text.split(/\r\n|\r|\n/).slice(1);
+  const indents = lines.filter(line => line.trim() !== '').map(line => /^[\t ]*/.exec(line)[0].length);
+  const removed = base?.length ?? (indents.length === 0 ? 0 : Math.min(...indents));
+  return removed === 0 ? text : text.replace(/(\r\n|\r|\n)([^\r\n]*)/g, (_match, lineBreak, line) => lineBreak + line.slice(Math.min(removed, /^[\t ]*/.exec(line)[0].length)));
+}
+function sizeOf(parsed) {
+  return (parsed.transforms?.length ?? 0) + (parsed.fields?.reduce((count, field) => count + field.ranges.length + (field.linked?.length ?? 0), 1) ?? parsed.stops.length);
+}
+/*
+ * Inserts a snippet at every placement, the last of them the primary one, and starts a session on its tab stops. The
+ * variables are resolved for each placement (`extra` first, then the host's and the built-in ones), the lines are indented
+ * to the text before the placement, and a running session takes the insertion as a nested one. False when nothing was inserted.
+ */
+export async function insertSnippet(language, source, placements, extra) {
+  const {
+    editor,
+    project,
+    uri,
+    snippets
+  } = language;
+  if (placements.length === 0 || editor.isReadOnly?.() === true) {
+    return false;
+  }
+  const template = compileSnippet(source);
+  const now = new Date();
+  const token = snippets.token;
+  const continuing = snippets.isActive;
+  let stale = false;
+  const off = editor.onTextChange(() => {
+    stale = true;
+  });
+  const current = () => !stale && snippets.token === token;
+  try {
+    let characters = 0;
+    let ranges = 0;
+    const drafts = placements.map((placement, index) => {
+      const line = lineTextOf(editor, placement.range.start.line);
+      const word = wordRangeAt(line, placement.range.start);
+      const resolver = createSnippetResolver({
+        uri,
+        languageId: language.languageId,
+        position: placement.range.start,
+        selection: placement.range,
+        selectedText: placement.selectedText ?? '',
+        currentLine: line,
+        currentWord: word === null ? '' : editor.textInRange(word),
+        cursorIndex: index,
+        cursorCount: placements.length,
+        folder: project.host.folder,
+        path: fileUriToPath(uri) ?? project.host.pathOfUri?.(uri) ?? undefined
+      }, project.host.resolveSnippetVariable?.bind(project.host), {
+        now
+      });
+      const resolve = name => extra?.(name) ?? resolver(name);
+      const raw = template.render(resolve, undefined, {
+        indentVariables: true
+      });
+      return {
+        placement,
+        resolve,
+        raw,
+        parsed: indentSnippet(raw, textBeforeOf(editor, placement.range.start))
+      };
+    });
+    for (const {
+      parsed
+    } of drafts) {
+      characters += parsed.text.length;
+      ranges += sizeOf(parsed);
+      if (parsed.limited === true || characters > MAX_CHARACTERS || ranges > MAX_RANGES) {
+        throw new LimitError();
+      }
+    }
+    await transformVariables(language, template, drafts, current);
+    if (!current()) {
+      return false;
+    }
+    const changes = drafts.map(draft => ({
+      range: draft.placement.range,
+      text: draft.parsed.text
+    }));
+    if (changes.reduce((total, change) => total + change.text.length, 0) > MAX_CHARACTERS) {
+      throw new LimitError();
+    }
+    // Insertions before one another move it, so each start is mapped through the changes in front of it.
+    const starts = changes.map(change => changes.filter(other => other !== change && comparePositions(other.range.end, change.range.start) <= 0).sort((left, right) => comparePositions(right.range.start, left.range.start)).reduce((place, other) => shiftPosition(place, other), change.range.start));
+    if (!(continuing ? snippets.applyEdits(changes, token) : editor.applyEdits(changes))) {
+      return false;
+    }
+    off();
+    place(language, drafts, starts, continuing && snippets.isActive && snippets.token === token);
+    editor.focus();
+    return true;
+  } catch (error) {
+    if (error instanceof LimitError || error instanceof SnippetTransformError && error.kind === 'range') {
+      project.host.notify?.({
+        id: TOAST_ID,
+        kind: 'error',
+        title: project.i18n.t('editor:language.completion.tooLarge')
+      });
+      return false;
+    }
+    if (error instanceof SnippetTransformQueueError) {
+      project.host.notify?.({
+        id: TOAST_ID,
+        kind: 'error',
+        title: project.i18n.t('editor:language.completion.transformBusy')
+      });
+      return false;
+    }
+    if (error instanceof SnippetTransformError) {
+      project.host.notify?.({
+        id: TOAST_ID,
+        kind: 'error',
+        title: project.i18n.t('editor:language.completion.transformFailed')
+      });
+      return false;
+    }
+    throw error;
+  } finally {
+    off();
+  }
+}
+/* Runs the transforms of variables through the worker, once for all placements, and renders them again with the answers. */
+async function transformVariables(language, template, drafts, current) {
+  const {
+    editor,
+    project,
+    snippets
+  } = language;
+  const {
+    jobs,
+    slotOf
+  } = jobTable();
+  const slots = drafts.map(draft => (draft.raw.transforms ?? []).map(range => slotOf({
+    ...range.transform,
+    value: draft.raw.text.slice(range.start, range.end)
+  })));
+  if (jobs.length === 0 || project.host.snippetTransformWorker === undefined) {
+    return;
+  }
+  if (jobs.length > MAX_TRANSFORM_JOBS || jobs.reduce((sum, job) => sum + job.value.length, 0) > MAX_TRANSFORM_WORK) {
+    throw new LimitError();
+  }
+  const values = await snippets.transformVariables(jobs, current);
+  if (values === null || !current()) {
+    return;
+  }
+  drafts.forEach((draft, index) => {
+    const raw = template.render(draft.resolve, slots[index].map(slot => values[slot]), {
+      indentVariables: true
+    });
+    const parsed = indentSnippet(raw, textBeforeOf(editor, draft.placement.range.start));
+    if (parsed.limited === true) {
+      throw new LimitError();
+    }
+    draft.raw = raw;
+    draft.parsed = parsed;
+  });
+}
+/* Starts the session on the tab stops, or puts the caret after the primary insertion when there are none. */
+function place(language, drafts, starts, nested) {
+  const {
+    editor,
+    snippets
+  } = language;
+  const primary = drafts.at(-1).parsed;
+  if (primary.stops.length > 0) {
+    snippets.beginInstances(drafts.map((draft, index) => ({
+      start: starts[index],
+      text: draft.parsed.text,
+      stops: tabOrder(draft.parsed),
+      fields: draft.parsed.fields
+    })), {
+      nested
+    });
+    return;
+  }
+  editor.setSelections(drafts.map((draft, index) => {
+    const end = positionInInsertion(starts[index], draft.parsed.text, draft.parsed.text.length);
+    return {
+      start: end,
+      end
+    };
+  }));
+}