@adecore/editor 0.0.1 → 0.17.0-beta.2

package/src/engine.ts

@@ -0,0 +1,764 @@
+import { changedSpans, DocumentModel, type EditorSnapshot, replacementText } from '@adecore/editor-core';
+import { InputController } from './controller.ts';
+import { resolveSmartKeys } from './smart-keys.ts';
+import { emit, type Listener, subscribe } from './listeners.ts';
+import type {
+    Editor,
+    EditorAttributionHover,
+    EditorAttributionMark,
+    EditorBlock,
+    EditorCodeBlockOptions,
+    EditorLineAction,
+    EditorLineHighlight,
+    EditorChangeMark,
+    EditorCodeVision,
+    EditorClickHandler,
+    EditorContextMenu,
+    EditorContentChange,
+    EditorEngine,
+    EditorFindQuery,
+    EditorFoldHints,
+    EditorFoldOutline,
+    EditorFolds,
+    EditorIndentation,
+    EditorFindState,
+    EditorReplaceOptions,
+    EditorGutterAction,
+    EditorGutterMarker,
+    EditorHighlight,
+    EditorHover,
+    EditorGhostText,
+    EditorInlayHint,
+    EditorKeyHandler,
+    EditorMarker,
+    EditorOptions,
+    EditorPosition,
+    EditorRemoteCursor,
+    EditorRange,
+    EditorReveal,
+    EditorRect,
+    EditorRunCommand,
+    EditorSelectionRanges,
+    EditorSemanticToken,
+    EditorSmartKeys,
+    EditorTextChange,
+    EditorTrackedRange,
+    EditorTheme,
+    EditorWidget,
+    SmartEditorEngineOptions
+} from './types.ts';
+import { fillLens, lensSignature } from './lens.ts';
+import { EditorView, type ViewSettings } from './view.ts';
+
+const DEFAULT_TAB_SIZE = 4;
+const DEFAULT_LABEL = 'Code editor';
+const DEFAULT_WIDGET_OWNER = 'default';
+
+class SmartEditor implements Editor {
+    private readonly model: DocumentModel;
+    private readonly settings: ViewSettings;
+    private readonly view: EditorView;
+    private readonly controller: InputController;
+    private readonly changes = new Set<Listener>();
+    private readonly textChanges = new Set<(change: EditorTextChange) => void>();
+    private readonly carets = new Set<(position: EditorPosition) => void>();
+    private caretOffset = 0;
+    private readonly saves = new Set<Listener>();
+    private readonly blurs = new Set<Listener>();
+    private readonly subscription: { dispose(): void };
+    private language: string | undefined;
+    private theme: EditorTheme;
+    private revision: number;
+    private lensRows = new Map<string, EditorCodeVision>();
+    private lensRevisions = new Map<string, { signature: string; revision: number }>();
+    private tokenizerRequest = 0;
+    private settingText = false;
+    private disposed = false;
+
+    private readonly engine: SmartEditorEngineOptions;
+
+    constructor(engine: SmartEditorEngineOptions, element: HTMLElement, options: EditorOptions) {
+        this.engine = engine;
+        this.model = new DocumentModel(options.text);
+        this.language = options.language;
+        this.theme = options.theme;
+        this.settings = {
+            language: options.language,
+            tabSize: options.indentation?.tabSize ?? DEFAULT_TAB_SIZE,
+            insertSpaces: options.indentation?.insertSpaces ?? true,
+            readOnly: options.readOnly ?? false,
+            readOnlyReason: options.readOnlyReason,
+            wrap: options.wrap ?? false,
+            smartKeys: resolveSmartKeys(options.smartKeys),
+            messages: options.messages ?? {},
+            label: options.label ?? DEFAULT_LABEL,
+            guides: options.guides !== false,
+            whitespace: options.whitespace === true,
+            rightMargin: options.rightMargin ?? null,
+            foldOutline: options.foldOutline ?? 'hover'
+        };
+        this.view = new EditorView(element, this.model, this.settings);
+        this.controller = new InputController(this.view, {
+            handBack: engine.handBack ?? [],
+            keymap: engine.keymap,
+            apple: engine.apple ?? false,
+            save: () => emit(this.saves),
+            blur: () => emit(this.blurs)
+        });
+        this.revision = this.model.getRevision();
+        this.caretOffset = this.model.getPrimary().head;
+        this.subscription = this.model.subscribe((snapshot) => {
+            this.caretMoved(snapshot.selections.at(-1)!.head);
+            if (snapshot.revision !== this.revision) {
+                this.revision = snapshot.revision;
+                if (snapshot.contentEdits !== undefined && snapshot.contentEdits.length > 0) {
+                    this.announceTextChange(snapshot.contentEdits, snapshot.source ?? 'external');
+                }
+                if (!this.settingText) {
+                    emit(this.changes);
+                }
+            }
+        });
+        this.loadTokenizer();
+        if (options.folds !== undefined || options.foldDefaults !== undefined) {
+            this.view.restoreFolds(options.folds ?? null, options.foldDefaults);
+        }
+        this.placeCursor(options);
+    }
+
+    /* Where the editor opens: on a line and column, scrolled to a position, or with that line in view. */
+    private placeCursor(options: EditorOptions): void {
+        if (options.line !== undefined) {
+            const line = this.clampLine(options.line);
+            const bounds = this.model.getLine(line);
+            const offset = Math.min(bounds.end, bounds.start + Math.max(0, (options.column ?? 1) - 1));
+            this.model.setSelections([{ anchor: offset, head: offset }]);
+            if (options.scrollTop === undefined) {
+                // A file opens where it is told to, without travelling there.
+                this.view.revealOffset(offset, 'center', false);
+            }
+        }
+        if (options.scrollTop !== undefined) {
+            this.view.render();
+            this.view.viewport.scrollTop = options.scrollTop;
+            this.view.render();
+        }
+    }
+
+    private loadTokenizer(): void {
+        const request = ++this.tokenizerRequest;
+        void this.engine
+            .scopeColors?.(this.theme)
+            .catch(() => null)
+            .then((colors) => {
+                if (!this.disposed && request === this.tokenizerRequest) {
+                    this.view.setScopeColors(colors ?? null);
+                }
+            });
+        void this.engine
+            .tokenizer(this.language, this.theme, this.model.getText())
+            .catch(() => null)
+            .then((tokenizer) => {
+                if (!this.disposed && request === this.tokenizerRequest) {
+                    this.view.setTokenizer(tokenizer);
+                }
+            });
+    }
+
+    getText(): string {
+        return this.model.getText();
+    }
+
+    setText(text: string): void {
+        const spans = changedSpans(this.model.getText(), text);
+        if (spans.length === 0) {
+            return;
+        }
+        this.settingText = true;
+        try {
+            // Edits and not a reset, which would drop the undo history and put the cursor on line one.
+            this.model.applyEdits(
+                spans.map((span) => ({ from: span.start, to: span.end, text: span.text })),
+                { source: 'external' }
+            );
+        } finally {
+            this.settingText = false;
+        }
+    }
+
+    onChange(listener: Listener): () => void {
+        return subscribe(this.changes, listener);
+    }
+
+    onTextChange(listener: (change: EditorTextChange) => void): () => void {
+        this.textChanges.add(listener);
+        return () => {
+            this.textChanges.delete(listener);
+        };
+    }
+
+    private announceTextChange(edits: NonNullable<EditorSnapshot['contentEdits']>, source: EditorTextChange['source']): void {
+        const change: EditorTextChange = {
+            source,
+            changes: edits.map((edit) => ({
+                range: { start: { line: edit.start.line, character: edit.start.column }, end: { line: edit.end.line, character: edit.end.column } },
+                text: edit.text
+            }))
+        };
+        for (const listener of [...this.textChanges]) {
+            listener(change);
+        }
+    }
+
+    private caretMoved(head: number): void {
+        if (head === this.caretOffset) {
+            return;
+        }
+        this.caretOffset = head;
+        const position = this.positionAt(head);
+        for (const listener of [...this.carets]) {
+            listener(position);
+        }
+    }
+
+    getCaret(): EditorPosition {
+        return this.positionAt(this.model.getPrimary().head);
+    }
+
+    getScrollTop(): number {
+        return this.view.scrollPlace.y;
+    }
+
+    getSelection(): EditorRange {
+        const { anchor, head } = this.model.getPrimary();
+        return { start: this.positionAt(Math.min(anchor, head)), end: this.positionAt(Math.max(anchor, head)) };
+    }
+
+    getSelections(): EditorRange[] {
+        return this.model.getSelections().map(({ anchor, head }) => ({
+            start: this.positionAt(Math.min(anchor, head)),
+            end: this.positionAt(Math.max(anchor, head))
+        }));
+    }
+
+    getIndentation(): EditorIndentation {
+        return { tabSize: this.settings.tabSize, insertSpaces: this.settings.insertSpaces };
+    }
+
+    setCaret(position: EditorPosition, reveal: EditorReveal = 'relative'): void {
+        const offset = this.offsetAt(position);
+        this.model.setSelections([{ anchor: offset, head: offset }]);
+        this.view.revealOffset(offset, reveal);
+    }
+
+    setSelection(range: EditorRange, reveal: EditorReveal = 'relative'): void {
+        const head = this.offsetAt(range.end);
+        this.model.setSelections([{ anchor: this.offsetAt(range.start), head }]);
+        this.view.revealOffset(head, reveal);
+    }
+
+    setSelections(ranges: readonly EditorRange[], reveal: EditorReveal = 'relative'): void {
+        const last = ranges.at(-1);
+        if (last === undefined) {
+            return;
+        }
+        this.model.setSelections(ranges.map((range) => ({ anchor: this.offsetAt(range.start), head: this.offsetAt(range.end) })));
+        this.view.revealOffset(this.offsetAt(last.end), reveal);
+    }
+
+    onCaret(listener: (position: EditorPosition) => void): () => void {
+        this.carets.add(listener);
+        return () => {
+            this.carets.delete(listener);
+        };
+    }
+
+    onHover(listener: (hover: EditorHover | null) => void): () => void {
+        return this.view.onHover((offset) => {
+            const rect = offset === null ? null : this.view.clientRectOf(offset);
+            listener(offset === null || rect === null ? null : { position: this.positionAt(offset), rect });
+        });
+    }
+
+    rectAt(position: EditorPosition): EditorRect | null {
+        return this.view.clientRectOf(this.offsetAt(position));
+    }
+
+    onViewChange(listener: Listener): () => void {
+        return this.view.onViewChange(listener);
+    }
+
+    onClick(handler: EditorClickHandler): () => void {
+        return this.controller.onClick(handler);
+    }
+
+    onContextMenu(listener: (menu: EditorContextMenu) => void): () => void {
+        return this.controller.onContextMenu(listener);
+    }
+
+    onKeyDown(handler: EditorKeyHandler): () => void {
+        return this.controller.onKeyDown(handler);
+    }
+
+    setSelectionRanges(provider: EditorSelectionRanges | null): void {
+        this.controller.setSelectionRanges(provider);
+    }
+
+    applyEdits(edits: readonly EditorContentChange[]): boolean {
+        if (this.settings.readOnly || edits.length === 0) {
+            return false;
+        }
+        try {
+            return this.model.applyEdits(
+                edits.map((edit) => ({ from: this.offsetAt(edit.range.start), to: this.offsetAt(edit.range.end), text: edit.text })),
+                { source: 'command' }
+            );
+        } catch {
+            return false;
+        }
+    }
+
+    setMarkers(markers: readonly EditorMarker[]): void {
+        this.view.setMarkers(
+            markers.map((marker) => ({
+                severity: marker.severity,
+                from: this.offsetAt(marker.range.start),
+                to: this.offsetAt(marker.range.end),
+                unnecessary: marker.unnecessary === true,
+                deprecated: marker.deprecated === true,
+                ...(marker.message === undefined ? {} : { message: marker.message })
+            }))
+        );
+    }
+
+    setInlayHints(hints: readonly EditorInlayHint[]): void {
+        this.view.setInlays(hints.map((hint, index) => ({ id: `hint-${index}`, at: this.offsetAt(hint.position), text: hint.label })));
+    }
+
+    setGhostText(ghost: EditorGhostText | null): void {
+        this.view.setGhost(ghost === null ? null : { at: this.offsetAt(ghost.position), text: ghost.text, accessory: ghost.accessory });
+    }
+
+    setSemanticTokens(tokens: readonly EditorSemanticToken[] | null): void {
+        this.view.setSemanticTokens(
+            tokens === null
+                ? null
+                : tokens.map((token) => {
+                      const from = this.offsetAt({ line: token.line, character: token.character });
+                      return { from, to: from + token.length, scopes: token.scopes };
+                  })
+        );
+    }
+
+    setHighlights(highlights: readonly EditorHighlight[]): void {
+        this.view.setOccurrences(
+            highlights.map((highlight) => ({ from: this.offsetAt(highlight.range.start), to: this.offsetAt(highlight.range.end), kind: highlight.kind }))
+        );
+    }
+
+    setLink(range: EditorRange | null): void {
+        this.view.setLink(range === null ? null : { from: this.offsetAt(range.start), to: this.offsetAt(range.end) });
+    }
+
+    getVisibleRange(): EditorRange {
+        const { first, last } = this.view.visibleLines();
+        return { start: { line: first, character: 0 }, end: this.positionAt(this.model.getLine(last).end) };
+    }
+
+    positionAt(offset: number): EditorPosition {
+        const { line, column } = this.model.positionAt(offset);
+        return { line, character: column };
+    }
+
+    textInRange(range: EditorRange): string {
+        return this.model.slice(this.offsetAt(range.start), this.offsetAt(range.end));
+    }
+
+    offsetAt(position: EditorPosition): number {
+        return this.model.offsetAt({ line: Math.max(0, position.line), column: Math.max(0, position.character) });
+    }
+
+    onSave(listener: Listener): () => void {
+        return subscribe(this.saves, listener);
+    }
+
+    onBlur(listener: Listener): () => void {
+        return subscribe(this.blurs, listener);
+    }
+
+    revealLine(line: number, reveal: EditorReveal = 'center'): void {
+        const bounds = this.model.getLine(this.clampLine(line));
+        this.model.setSelections([{ anchor: bounds.start, head: bounds.start }]);
+        this.view.revealOffset(bounds.start, reveal);
+    }
+
+    find(query: EditorFindQuery | null): void {
+        this.view.setFind(query, true);
+    }
+
+    findStep(direction: 1 | -1): void {
+        this.view.stepFind(direction);
+    }
+
+    replace(replacement: string, replaceOptions: EditorReplaceOptions = {}): boolean {
+        const { find } = this.view;
+        const mark = find.currentMark;
+        const query = find.activeQuery;
+        if (mark === null || query === null || this.blockedByReadOnly()) {
+            return false;
+        }
+        try {
+            const options = { caseSensitive: query.caseSensitive, wholeWord: query.wholeWord, regex: query.regex, from: mark.from, to: mark.to, maxResults: 1 };
+            const match = this.model.find(query.text, options)[0];
+            if (match === undefined) {
+                return false;
+            }
+            // The next match is looked for after what was written, or a replacement that holds the query would find itself again.
+            find.pendingAnchor = mark.from + replacementText(this.model.getText(), match, replacement, false, replaceOptions.preserveCase).length;
+            if (!this.model.replace(match, replacement, { preserveCase: replaceOptions.preserveCase })) {
+                find.pendingAnchor = undefined;
+                return false;
+            }
+        } catch {
+            find.pendingAnchor = undefined;
+            return false;
+        }
+        this.view.revealFind();
+        this.view.render();
+        return true;
+    }
+
+    replaceAll(replacement: string, options: EditorReplaceOptions = {}): number {
+        const query = this.view.find.activeQuery;
+        if (query === null || this.blockedByReadOnly()) {
+            return 0;
+        }
+        try {
+            return this.model.replaceAll(query.text, replacement, {
+                caseSensitive: query.caseSensitive,
+                wholeWord: query.wholeWord,
+                regex: query.regex,
+                preserveCase: options.preserveCase,
+                ...this.view.find.scope
+            });
+        } catch {
+            return 0;
+        }
+    }
+
+    setReplacePreview(replacement: string | null, options: EditorReplaceOptions = {}): void {
+        this.view.setReplacePreview(replacement, options.preserveCase === true);
+    }
+
+    selectFindMatches(): number {
+        const { find } = this.view;
+        const marks = find.matches;
+        if (marks.length === 0) {
+            return 0;
+        }
+        const current = find.current ?? marks.length - 1;
+        const ordered = [...marks.slice(0, current), ...marks.slice(current + 1), marks[current]!];
+        this.view.setFind(null, false);
+        for (const mark of ordered) {
+            this.view.ensureVisible(mark.from);
+        }
+        this.model.setSelections(ordered.map((mark) => ({ anchor: mark.from, head: mark.to })));
+        this.view.revealCaret();
+        return ordered.length;
+    }
+
+    findFromCursor(query: EditorFindQuery, direction: 1 | -1): boolean {
+        if (query.text === '') {
+            return false;
+        }
+        let matches;
+        try {
+            matches = this.model.find(query.text, { caseSensitive: query.caseSensitive, wholeWord: query.wholeWord, regex: query.regex });
+        } catch {
+            return false;
+        }
+        if (matches.length === 0) {
+            return false;
+        }
+        const { anchor, head } = this.model.getPrimary();
+        const from = Math.min(anchor, head);
+        const to = Math.max(anchor, head);
+        const target =
+            direction === 1 ? (matches.find((match) => match.from >= to) ?? matches[0]!) : (matches.findLast((match) => match.to <= from) ?? matches.at(-1)!);
+        this.view.ensureVisible(target.from);
+        this.model.setSelections([direction === 1 ? { anchor: target.from, head: target.to } : { anchor: target.to, head: target.from }]);
+        this.view.revealCaret(target.from > head ? 'centerDown' : 'centerUp');
+        return true;
+    }
+
+    private blockedByReadOnly(): boolean {
+        if (!this.settings.readOnly) {
+            return false;
+        }
+        if (this.settings.readOnlyReason) {
+            this.view.notify(this.settings.readOnlyReason);
+        }
+        return true;
+    }
+
+    onFind(listener: (state: EditorFindState) => void): () => void {
+        return this.view.onFind(listener);
+    }
+
+    endFind(): void {
+        const mark = this.view.find.currentMark;
+        this.view.setFind(null, false);
+        if (mark) {
+            this.view.ensureVisible(mark.from);
+            this.model.setSelections([{ anchor: mark.from, head: mark.to }]);
+            this.view.revealCaret();
+        }
+    }
+
+    setWrap(wrap: boolean): void {
+        this.settings.wrap = wrap;
+        if (wrap) {
+            this.view.viewport.scrollLeft = 0;
+        }
+        this.view.applySettings();
+    }
+
+    setChangeMarks(marks: readonly EditorChangeMark[]): void {
+        this.view.setChangeMarks(marks);
+    }
+
+    setAttributionMarks(marks: readonly EditorAttributionMark[]): void {
+        this.view.setAttributionMarks(marks);
+    }
+
+    setLineHighlights(highlights: readonly EditorLineHighlight[]): void {
+        this.view.setLineHighlights(highlights);
+    }
+
+    renderCode(container: HTMLElement, text: string, options: EditorCodeBlockOptions = {}): void {
+        this.view.renderCode(container, text, options);
+    }
+
+    setRemoteCursors(cursors: readonly EditorRemoteCursor[]): void {
+        this.view.setRemoteCarets(cursors.map((cursor) => ({ id: cursor.id, name: cursor.name, color: cursor.color, at: this.offsetAt(cursor.position) })));
+    }
+
+    onAttributionHover(listener: (hover: EditorAttributionHover | null) => void): () => void {
+        return this.view.onAttributionHover(listener);
+    }
+
+    setWidgets(widgets: readonly EditorWidget[], owner: string = DEFAULT_WIDGET_OWNER): void {
+        this.view.setBlockWidgets(
+            owner,
+            widgets.map((widget) => ({
+                id: `widget:${owner}:${widget.id}`,
+                at: this.offsetAt({ line: widget.line, character: 0 }),
+                placement: widget.placement ?? 'below',
+                height: widget.height,
+                render: (container: HTMLElement) => {
+                    container.classList.add('se-widget');
+                    widget.render(container);
+                }
+            }))
+        );
+    }
+
+    setLineActions(actions: readonly EditorLineAction[], owner: string = DEFAULT_WIDGET_OWNER): void {
+        this.view.setLineActions(
+            owner,
+            actions.map((action) => ({
+                id: action.id,
+                at: this.offsetAt({ line: action.line, character: 0 }),
+                render: (container) => action.render(container)
+            }))
+        );
+    }
+
+    trackRange(range: EditorRange): EditorTrackedRange {
+        const tracked = this.view.trackRange(this.offsetAt(range.start), this.offsetAt(range.end));
+        return {
+            get: () => {
+                const offsets = tracked.get();
+                return offsets === null ? null : { start: this.positionAt(offsets.from), end: this.positionAt(offsets.to) };
+            },
+            dispose: () => tracked.dispose()
+        };
+    }
+
+    setCodeVision(rows: readonly EditorCodeVision[]): void {
+        const current = new Map(rows.map((row) => [row.id, row]));
+        const revisions = new Map<string, { signature: string; revision: number }>();
+        for (const row of rows) {
+            const signature = lensSignature(row.entries);
+            const before = this.lensRevisions.get(row.id);
+            revisions.set(row.id, {
+                signature,
+                revision: before === undefined || before.signature === signature ? (before?.revision ?? 0) : before.revision + 1
+            });
+        }
+        this.lensRows = current;
+        this.lensRevisions = revisions;
+        this.view.setLenses(
+            rows.map((row) => ({
+                id: `lens:${row.id}`,
+                at: this.indentOffsetOf(row.line),
+                placement: 'above' as const,
+                lens: true,
+                revision: revisions.get(row.id)!.revision,
+                render: (container: HTMLElement) =>
+                    fillLens(container, row.entries, (id) => this.lensRows.get(row.id)?.entries.find((entry) => entry.id === id))
+            }))
+        );
+    }
+
+    /* Where the text of a line begins after its indentation, so a row sitting there stays with the declaration when something is typed in front of it. */
+    private indentOffsetOf(line: number): number {
+        const { start, text } = this.model.getLine(Math.max(0, Math.min(line, this.model.getLineCount() - 1)));
+        return start + (/^[ \t]*/.exec(text)?.[0].length ?? 0);
+    }
+
+    setGutterAction(action: EditorGutterAction | null): void {
+        this.view.setGutterAction(action);
+    }
+
+    onGutterAction(listener: (line: number) => void): () => void {
+        return this.view.onGutterAction(listener);
+    }
+
+    setGutterMarkers(markers: readonly EditorGutterMarker[], owner: string = 'default'): void {
+        this.view.setGutterMarkers(owner, markers);
+    }
+
+    onGutterMarker(listener: (id: string) => void): () => void {
+        return this.view.onGutterMarker(listener);
+    }
+
+    setBlocks(blocks: readonly EditorBlock[] | null): void {
+        this.view.setBlocks(blocks);
+    }
+
+    onScope(listener: (scope: readonly EditorBlock[]) => void): () => void {
+        return this.view.onScope(listener);
+    }
+
+    setGuides(guides: boolean): void {
+        this.settings.guides = guides;
+        this.view.applySettings();
+    }
+
+    setWhitespace(whitespace: boolean): void {
+        this.settings.whitespace = whitespace;
+        this.view.applySettings();
+    }
+
+    setRightMargin(column: number | null): void {
+        this.settings.rightMargin = column;
+        this.view.applySettings();
+    }
+
+    setFoldOutline(outline: EditorFoldOutline): void {
+        this.settings.foldOutline = outline;
+        this.view.applySettings();
+    }
+
+    setLabel(label: string): void {
+        this.settings.label = label;
+        this.view.applySettings();
+    }
+
+    setFoldHints(hints: EditorFoldHints | null): void {
+        this.view.setFoldHints(
+            hints === null
+                ? null
+                : {
+                      symbols: (hints.symbols ?? []).map((symbol) => ({
+                          from: this.offsetAt(symbol.range.start),
+                          to: this.offsetAt(symbol.range.end),
+                          body: symbol.body
+                      })),
+                      ranges: (hints.ranges ?? []).map((range) => ({
+                          from: this.model.getLine(Math.min(range.startLine, this.model.getLineCount() - 1)).start,
+                          to: this.model.getLine(Math.min(range.endLine, this.model.getLineCount() - 1)).start,
+                          ...(range.kind === undefined ? {} : { kind: range.kind })
+                      }))
+                  }
+        );
+    }
+
+    setSmartKeys(keys: Partial<EditorSmartKeys>): void {
+        this.settings.smartKeys = { ...this.settings.smartKeys, ...keys };
+    }
+
+    setIndentation(indentation: EditorIndentation): void {
+        if (indentation.tabSize === this.settings.tabSize && indentation.insertSpaces === this.settings.insertSpaces) {
+            return;
+        }
+        this.settings.tabSize = indentation.tabSize;
+        this.settings.insertSpaces = indentation.insertSpaces;
+        this.view.applySettings();
+    }
+
+    setTheme(theme: EditorTheme): void {
+        if (theme !== this.theme) {
+            this.theme = theme;
+            this.loadTokenizer();
+        }
+    }
+
+    refreshFont(): void {
+        this.view.refreshFont();
+    }
+
+    setReadOnly(readOnly: boolean, reason?: string): void {
+        this.settings.readOnly = readOnly;
+        this.settings.readOnlyReason = reason;
+        this.view.applySettings();
+    }
+
+    runCommand(command: EditorRunCommand): boolean {
+        return this.controller.command(command);
+    }
+
+    getFolds(): EditorFolds {
+        return this.view.getFolds();
+    }
+
+    focus(): void {
+        this.view.focus();
+    }
+
+    dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.changes.clear();
+        this.textChanges.clear();
+        this.carets.clear();
+        this.saves.clear();
+        this.blurs.clear();
+        this.subscription.dispose();
+        this.controller.dispose();
+        this.view.dispose();
+    }
+
+    private clampLine(line: number): number {
+        return Math.min(Math.max(1, Math.trunc(line) || 1), this.model.getLineCount()) - 1;
+    }
+}
+
+class SmartEditorEngine implements EditorEngine {
+    private readonly options: SmartEditorEngineOptions;
+
+    constructor(options: SmartEditorEngineOptions) {
+        this.options = options;
+    }
+
+    mount(element: HTMLElement, options: EditorOptions): Editor {
+        return new SmartEditor(this.options, element, options);
+    }
+}
+
+export function createSmartEditorEngine(options: SmartEditorEngineOptions): EditorEngine {
+    return new SmartEditorEngine(options);
+}