@adecore/editor-react 0.42.0 → 0.44.0

package/src/project-language.ts

@@ -1,7 +1,21 @@
 import { disposeSnippetTransforms } from './snippet-transform-queue.ts';
 import i18next, { type i18n } from 'i18next';
-import { fileUriToPath, pathToFileUri, type ApplyWorkspaceEditResult, type ContentChange, type LanguageService, type WorkspaceEdit } from '@adecore/lsp';
+import {
+    fileUriToPath,
+    pathToFileUri,
+    unservedLanguageService,
+    type ApplyWorkspaceEditResult,
+    type ContentChange,
+    type Disposable,
+    type LanguageService,
+    type ShowDocumentParams,
+    type ShowDocumentResult,
+    type WorkspaceEdit
+} from '@adecore/lsp';
 import type { Editor, EditorPosition } from '@adecore/editor';
+import { ClipboardHistory } from './clipboard-history.ts';
+import { TemplateRegistry } from './templates.ts';
+import { EditLocations } from './edit-locations.ts';
 import { NavigationHistory, type Place } from './navigation-history.ts';
 import { ProjectProblems, serviceProblems } from './project-problems.ts';
 import { applyWorkspaceEdit, type ProjectFiles } from './workspace-edit.ts';
@@ -16,6 +30,8 @@ export interface LanguageDocumentHandle {
     release(): void;
 }
 
+const UNSERVED = unservedLanguageService();
+
 /* Sends one editor's edits to the document, holding them until the document is open. */
 class DocumentSync {
     readonly ready: Promise<void>;
@@ -76,10 +92,18 @@ class DocumentSync {
 
 interface Holder {
     readonly editors: Editor[];
-    sync: DocumentSync;
+    /* The editors a server serves, in the order they came; the first one sends the changes. */
+    readonly served: Editor[];
+    /* Null while no editor of the document is served, so nothing of it is open in the service. */
+    sync: DocumentSync | null;
     languageId: string;
 }
 
+export interface AcquireOptions {
+    /* False registers the editor as open without telling the service, for a document no server serves; true by default. */
+    readonly serve?: boolean;
+}
+
 /* A file or folder for a file operation notification: a bare path is a file. */
 export type FileOperationTarget = string | { readonly path: string; readonly directory?: boolean };
 
@@ -103,6 +127,9 @@ export class ProjectLanguage {
     readonly folder: string;
     readonly problems: ProjectProblems;
     readonly history = new NavigationHistory();
+    readonly edits: EditLocations;
+    readonly clipboard: ClipboardHistory;
+    readonly templates: TemplateRegistry;
     private readonly holders = new Map<string, Holder>();
     private readonly files: ProjectFiles | null;
 
@@ -113,6 +140,9 @@ export class ProjectLanguage {
     private pendingCaret: Place | null = null;
     private lastPlace: Place | null = null;
     private disposed = false;
+    private readonly subscriptions: readonly Disposable[];
+    /* The result id the server gave each document in its last workspace report, which the next asks with. */
+    private readonly workspaceResults = new Map<string, string>();
 
     constructor(service: LanguageService, host: LanguageHost = {}) {
         this.service = service;
@@ -120,8 +150,14 @@ export class ProjectLanguage {
         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. */
@@ -182,20 +218,73 @@ export class ProjectLanguage {
 
     /* Tells the servers that files were deleted, once they are. */
     didDeleteFiles(targets: readonly FileOperationTarget[]): Promise<void> {
-        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: string): Promise<string | null> {
-        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);
+        if (path === null) {
+            return (await this.service.textDocumentContent?.(uri).catch(() => null)) ?? null;
+        }
 
-        return path === null || this.files === null ? null : ((await this.files.read(path))?.text ?? 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: string, options: { readonly signal?: AbortSignal } = {}): Promise<boolean> {
+        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. */
+    private async showDocument(params: ShowDocumentParams): Promise<ShowDocumentResult> {
+        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 };
     }
 
     /*
@@ -234,27 +323,39 @@ export class ProjectLanguage {
         return pending.position;
     }
 
+    /* The editors that hold a document, one per uri in the order the documents were first opened. */
+    openEditors(): readonly { uri: string; editor: Editor }[] {
+        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: string, languageId: string, editor: Editor): LanguageDocumentHandle {
+    acquire(uri: string, languageId: string, editor: Editor, options: AcquireOptions = {}): LanguageDocumentHandle {
         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), languageId };
+            holder = { editors: [], 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) {
@@ -273,26 +374,38 @@ export class ProjectLanguage {
         }
 
         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
+        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.has(uri)) {
+                    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);
         }
     }
 
@@ -302,9 +415,16 @@ export class ProjectLanguage {
         }
 
         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

package/src/rename.ts

@@ -67,9 +67,9 @@ export class RenameFeature {
     }
 
     async start(): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
 
-        if (!project.service.supports(METHOD, uri)) {
+        if (!this.language.service.supports(METHOD, uri)) {
             this.tell('error', this.say('unavailable'));
 
             return;
@@ -77,11 +77,11 @@ export class RenameFeature {
 
         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: PrepareRenameResult;
 
         try {
-            answer = prepare ? await project.service.prepareRename(uri, caret) : { defaultBehavior: true };
+            answer = prepare ? await this.language.service.prepareRename(uri, caret) : { defaultBehavior: true };
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
                 this.tell('error', this.say('nothing'));
@@ -127,7 +127,7 @@ export class RenameFeature {
         const { project, 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;
@@ -218,14 +218,14 @@ export class RenameFeature {
 
     /* Lights up the places the name has in this file, and counts them all; what the servers listed, or null when they did not. */
     private async light(session: Session): Promise<readonly Location[] | null> {
-        const { editor, project, uri } = this.language;
+        const { editor, 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;
@@ -277,14 +277,14 @@ 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. */
     private async kindOf(session: Session, locations: readonly Location[]): Promise<string | undefined> {
-        const { project, uri } = this.language;
+        const { 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, { signal: session.names.signal, parallel: true });
+            const symbols = await this.language.service.documentSymbols(uri, { signal: session.names.signal, parallel: true });
 
             return renameKindOf(symbols, session.original, [session.target.range, ...occurrencesOf(locations, uri).inFile]);
         } catch {

package/src/rendered-docs.ts

@@ -254,9 +254,9 @@ export class RenderedDocsFeature {
 
     /* Whether names in `{@link}` and `@see` can be followed, which takes a server that finds symbols by name. */
     get canFollow(): boolean {
-        const { project, uri } = this.language;
+        const { 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. */

package/src/selection-ranges.ts

@@ -21,14 +21,14 @@ export function selectionChainOf(selection: SelectionRange): EditorRange[] {
  */
 export class SelectionRangesFeature {
     constructor(language: EditorLanguage) {
-        const { editor, project, uri } = language;
+        const { editor, 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);
         });

package/src/signature.ts

@@ -111,8 +111,8 @@ export class SignatureFeature {
     }
 
     private options(): { triggers: readonly string[]; retriggers: readonly string[] } | null {
-        const { project, uri } = this.language;
-        const options = project.service.providerOptions(METHOD, uri);
+        const { uri } = this.language;
+        const options = this.language.service.providerOptions(METHOD, uri);
 
         return options === undefined ? null : { triggers: options.triggerCharacters ?? [], retriggers: options.retriggerCharacters ?? [] };
     }
@@ -147,9 +147,9 @@ export class SignatureFeature {
     }
 
     private ask(context: Omit<SignatureHelpContext, 'activeSignatureHelp'>): void {
-        const { project, uri } = this.language;
+        const { uri } = this.language;
 
-        if (!project.service.supports(METHOD, uri)) {
+        if (!this.language.service.supports(METHOD, uri)) {
             return;
         }
 
@@ -160,7 +160,7 @@ export class SignatureFeature {
     }
 
     private async fetch(context: SignatureHelpContext, request: number): Promise<void> {
-        const { editor, project, uri } = this.language;
+        const { editor, uri } = this.language;
         const caret = editor.getCaret();
         this.controller?.abort();
         const controller = new AbortController();
@@ -168,7 +168,7 @@ export class SignatureFeature {
         let help: SignatureHelp | null;
 
         try {
-            help = await project.service.signatureHelp(uri, caret, context, { signal: controller.signal });
+            help = await this.language.service.signatureHelp(uri, caret, context, { signal: controller.signal });
         } catch {
             return;
         }

package/src/snippet-insert.ts

@@ -0,0 +1,258 @@
+import { SnippetTransformQueueError } from './snippet-transform-queue.ts';
+import type { Editor, EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
+import { comparePositions, shiftPosition } from './diagnostics-model.ts';
+import type { EditorLanguage } from './editor-language.ts';
+import { lineTextOf, textBeforeOf } from './line-text.ts';
+import { wordRangeAt } from './rename-model.ts';
+import { jobTable } from './snippet-field-transforms.ts';
+import { indentSnippet } from './snippet-indent.ts';
+import { positionInInsertion } from './snippet-session.ts';
+import { SnippetTransformError } from './snippet-transform-client.ts';
+import { MAX_TRANSFORM_JOBS, MAX_TRANSFORM_WORK } from './snippet-transform-protocol.ts';
+import { compileSnippet, tabOrder, type ParsedSnippet, type SnippetTemplate } from './snippet.ts';
+import { createSnippetResolver } from './snippet-variables.ts';
+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';
+
+export interface SnippetPlacement {
+    readonly range: EditorRange;
+
+    /* The value of `TM_SELECTED_TEXT` at this placement; empty without it. */
+    readonly selectedText?: string;
+}
+
+class LimitError extends Error {}
+
+interface Draft {
+    readonly placement: SnippetPlacement;
+    readonly resolve: (name: string) => string | undefined;
+
+    /* As rendered, which is the text the variable transforms read. */
+    raw: ParsedSnippet;
+
+    /* Indented to the text before the placement. */
+    parsed: ParsedSnippet;
+}
+
+/* Each line's leading tabs become the editor's own indentation unit. */
+export function bodyWithIndentUnit(body: string, unit: string): string {
+    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: Editor): string {
+    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: string, base?: string): string {
+    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: string, line: string) => lineBreak + line.slice(Math.min(removed, /^[\t ]*/.exec(line)![0].length))
+          );
+}
+
+function sizeOf(parsed: ParsedSnippet): number {
+    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: EditorLanguage,
+    source: string,
+    placements: readonly SnippetPlacement[],
+    extra?: (name: string) => string | undefined
+): Promise<boolean> {
+    const { editor, project, uri, snippets } = language;
+
+    if (placements.length === 0 || editor.isReadOnly?.() === true) {
+        return false;
+    }
+
+    const template: SnippetTemplate = 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 = (): boolean => !stale && snippets.token === token;
+
+    try {
+        let characters = 0;
+        let ranges = 0;
+
+        const drafts = placements.map((placement, index): Draft => {
+            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: string): string | undefined => 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): EditorContentChange => ({ 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: EditorLanguage, template: SnippetTemplate, drafts: Draft[], current: () => boolean): Promise<void> {
+    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: EditorLanguage, drafts: readonly Draft[], starts: readonly EditorPosition[], nested: boolean): void {
+    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 };
+        })
+    );
+}