monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/edit.js

@@ -0,0 +1,183 @@
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { OffsetRange } from '../ranges/offsetRange.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class BaseEdit {
+    constructor(replacements) {
+        this.replacements = replacements;
+        let lastEndEx = -1;
+        for (const replacement of replacements) {
+            if (!(replacement.replaceRange.start >= lastEndEx)) {
+                throw new BugIndicatingError(`Edits must be disjoint and sorted. Found ${replacement} after ${lastEndEx}`);
+            }
+            lastEndEx = replacement.replaceRange.endExclusive;
+        }
+    }
+    toString() {
+        const edits = this.replacements.map(e => e.toString()).join(', ');
+        return `[${edits}]`;
+    }
+    /**
+     * Normalizes the edit by removing empty replacements and joining touching replacements (if the replacements allow joining).
+     * Two edits have an equal normalized edit if and only if they have the same effect on any input.
+     *
+     * ![](https://raw.githubusercontent.com/microsoft/vscode/refs/heads/main/src/vs/editor/common/core/edits/docs/BaseEdit_normalize.drawio.png)
+     *
+     * Invariant:
+     * ```
+     * (forall base: TEdit.apply(base).equals(other.apply(base))) <-> this.normalize().equals(other.normalize())
+     * ```
+     * and
+     * ```
+     * forall base: TEdit.apply(base).equals(this.normalize().apply(base))
+     * ```
+     *
+     */
+    normalize() {
+        const newReplacements = [];
+        let lastReplacement;
+        for (const r of this.replacements) {
+            if (r.getNewLength() === 0 && r.replaceRange.length === 0) {
+                continue;
+            }
+            if (lastReplacement && lastReplacement.replaceRange.endExclusive === r.replaceRange.start) {
+                const joined = lastReplacement.tryJoinTouching(r);
+                if (joined) {
+                    lastReplacement = joined;
+                    continue;
+                }
+            }
+            if (lastReplacement) {
+                newReplacements.push(lastReplacement);
+            }
+            lastReplacement = r;
+        }
+        if (lastReplacement) {
+            newReplacements.push(lastReplacement);
+        }
+        return this._createNew(newReplacements);
+    }
+    /**
+     * Combines two edits into one with the same effect.
+     *
+     * ![](https://raw.githubusercontent.com/microsoft/vscode/refs/heads/main/src/vs/editor/common/core/edits/docs/BaseEdit_compose.drawio.png)
+     *
+     * Invariant:
+     * ```
+     * other.apply(this.apply(s0)) = this.compose(other).apply(s0)
+     * ```
+     */
+    compose(other) {
+        const edits1 = this.normalize();
+        const edits2 = other.normalize();
+        if (edits1.isEmpty()) {
+            return edits2;
+        }
+        if (edits2.isEmpty()) {
+            return edits1;
+        }
+        const edit1Queue = [...edits1.replacements];
+        const result = [];
+        let edit1ToEdit2 = 0;
+        for (const r2 of edits2.replacements) {
+            // Copy over edit1 unmodified until it touches edit2.
+            while (true) {
+                const r1 = edit1Queue[0];
+                if (!r1 || r1.replaceRange.start + edit1ToEdit2 + r1.getNewLength() >= r2.replaceRange.start) {
+                    break;
+                }
+                edit1Queue.shift();
+                result.push(r1);
+                edit1ToEdit2 += r1.getNewLength() - r1.replaceRange.length;
+            }
+            const firstEdit1ToEdit2 = edit1ToEdit2;
+            let firstIntersecting; // or touching
+            let lastIntersecting; // or touching
+            while (true) {
+                const r1 = edit1Queue[0];
+                if (!r1 || r1.replaceRange.start + edit1ToEdit2 > r2.replaceRange.endExclusive) {
+                    break;
+                }
+                // else we intersect, because the new end of edit1 is after or equal to our start
+                if (!firstIntersecting) {
+                    firstIntersecting = r1;
+                }
+                lastIntersecting = r1;
+                edit1Queue.shift();
+                edit1ToEdit2 += r1.getNewLength() - r1.replaceRange.length;
+            }
+            if (!firstIntersecting) {
+                result.push(r2.delta(-edit1ToEdit2));
+            }
+            else {
+                const newReplaceRangeStart = Math.min(firstIntersecting.replaceRange.start, r2.replaceRange.start - firstEdit1ToEdit2);
+                const prefixLength = r2.replaceRange.start - (firstIntersecting.replaceRange.start + firstEdit1ToEdit2);
+                if (prefixLength > 0) {
+                    const prefix = firstIntersecting.slice(OffsetRange.emptyAt(newReplaceRangeStart), new OffsetRange(0, prefixLength));
+                    result.push(prefix);
+                }
+                if (!lastIntersecting) {
+                    throw new BugIndicatingError(`Invariant violation: lastIntersecting is undefined`);
+                }
+                const suffixLength = (lastIntersecting.replaceRange.endExclusive + edit1ToEdit2) - r2.replaceRange.endExclusive;
+                if (suffixLength > 0) {
+                    const e = lastIntersecting.slice(OffsetRange.ofStartAndLength(lastIntersecting.replaceRange.endExclusive, 0), new OffsetRange(lastIntersecting.getNewLength() - suffixLength, lastIntersecting.getNewLength()));
+                    edit1Queue.unshift(e);
+                    edit1ToEdit2 -= e.getNewLength() - e.replaceRange.length;
+                }
+                const newReplaceRange = new OffsetRange(newReplaceRangeStart, r2.replaceRange.endExclusive - edit1ToEdit2);
+                const middle = r2.slice(newReplaceRange, new OffsetRange(0, r2.getNewLength()));
+                result.push(middle);
+            }
+        }
+        while (true) {
+            const item = edit1Queue.shift();
+            if (!item) {
+                break;
+            }
+            result.push(item);
+        }
+        return this._createNew(result).normalize();
+    }
+    /**
+     * Returns the range of each replacement in the applied value.
+    */
+    getNewRanges() {
+        const ranges = [];
+        let offset = 0;
+        for (const e of this.replacements) {
+            ranges.push(OffsetRange.ofStartAndLength(e.replaceRange.start + offset, e.getNewLength()));
+            offset += e.getLengthDelta();
+        }
+        return ranges;
+    }
+    isEmpty() {
+        return this.replacements.length === 0;
+    }
+}
+class BaseReplacement {
+    constructor(
+    /**
+     * The range to be replaced.
+    */
+    replaceRange) {
+        this.replaceRange = replaceRange;
+    }
+    delta(offset) {
+        return this.slice(this.replaceRange.delta(offset), new OffsetRange(0, this.getNewLength()));
+    }
+    getLengthDelta() {
+        return this.getNewLength() - this.replaceRange.length;
+    }
+    toString() {
+        return `{ ${this.replaceRange.toString()} -> ${this.getNewLength()} }`;
+    }
+    get isEmpty() {
+        return this.getNewLength() === 0 && this.replaceRange.length === 0;
+    }
+    getRangeAfterReplace() {
+        return new OffsetRange(this.replaceRange.start, this.replaceRange.start + this.getNewLength());
+    }
+}
+
+export { BaseEdit, BaseReplacement };

package/dist/workers/editor/common/editOperation.js

@@ -0,0 +1,36 @@
+import { Range } from './range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class EditOperation {
+    static insert(position, text) {
+        return {
+            range: new Range(position.lineNumber, position.column, position.lineNumber, position.column),
+            text: text,
+            forceMoveMarkers: true
+        };
+    }
+    static delete(range) {
+        return {
+            range: range,
+            text: null
+        };
+    }
+    static replace(range, text) {
+        return {
+            range: range,
+            text: text
+        };
+    }
+    static replaceMove(range, text) {
+        return {
+            range: range,
+            text: text,
+            forceMoveMarkers: true
+        };
+    }
+}
+
+export { EditOperation };

package/dist/workers/editor/common/editStack.js

@@ -0,0 +1,363 @@
+import { localize } from '../../../nls.js';
+import { onUnexpectedError } from '../../../base/common/errors.js';
+import { Selection } from '../core/selection.js';
+import { URI } from '../../../base/common/uri.js';
+import { compressConsecutiveTextChanges, TextChange } from '../core/textChange.js';
+import { writeUInt32BE, readUInt32BE, writeUInt8, readUInt8 } from '../../../base/common/buffer.js';
+import { basename } from '../../../base/common/resources.js';
+import { EditSources } from '../textModelEditSource.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function uriGetComparisonKey(resource) {
+    return resource.toString();
+}
+class SingleModelEditStackData {
+    static create(model, beforeCursorState) {
+        const alternativeVersionId = model.getAlternativeVersionId();
+        const eol = getModelEOL(model);
+        return new SingleModelEditStackData(alternativeVersionId, alternativeVersionId, eol, eol, beforeCursorState, beforeCursorState, []);
+    }
+    constructor(beforeVersionId, afterVersionId, beforeEOL, afterEOL, beforeCursorState, afterCursorState, changes) {
+        this.beforeVersionId = beforeVersionId;
+        this.afterVersionId = afterVersionId;
+        this.beforeEOL = beforeEOL;
+        this.afterEOL = afterEOL;
+        this.beforeCursorState = beforeCursorState;
+        this.afterCursorState = afterCursorState;
+        this.changes = changes;
+    }
+    append(model, textChanges, afterEOL, afterVersionId, afterCursorState) {
+        if (textChanges.length > 0) {
+            this.changes = compressConsecutiveTextChanges(this.changes, textChanges);
+        }
+        this.afterEOL = afterEOL;
+        this.afterVersionId = afterVersionId;
+        this.afterCursorState = afterCursorState;
+    }
+    static _writeSelectionsSize(selections) {
+        return 4 + 4 * 4 * (selections ? selections.length : 0);
+    }
+    static _writeSelections(b, selections, offset) {
+        writeUInt32BE(b, (selections ? selections.length : 0), offset);
+        offset += 4;
+        if (selections) {
+            for (const selection of selections) {
+                writeUInt32BE(b, selection.selectionStartLineNumber, offset);
+                offset += 4;
+                writeUInt32BE(b, selection.selectionStartColumn, offset);
+                offset += 4;
+                writeUInt32BE(b, selection.positionLineNumber, offset);
+                offset += 4;
+                writeUInt32BE(b, selection.positionColumn, offset);
+                offset += 4;
+            }
+        }
+        return offset;
+    }
+    static _readSelections(b, offset, dest) {
+        const count = readUInt32BE(b, offset);
+        offset += 4;
+        for (let i = 0; i < count; i++) {
+            const selectionStartLineNumber = readUInt32BE(b, offset);
+            offset += 4;
+            const selectionStartColumn = readUInt32BE(b, offset);
+            offset += 4;
+            const positionLineNumber = readUInt32BE(b, offset);
+            offset += 4;
+            const positionColumn = readUInt32BE(b, offset);
+            offset += 4;
+            dest.push(new Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn));
+        }
+        return offset;
+    }
+    serialize() {
+        let necessarySize = (4 // beforeVersionId
+            + 4 // afterVersionId
+            + 1 // beforeEOL
+            + 1 // afterEOL
+            + SingleModelEditStackData._writeSelectionsSize(this.beforeCursorState)
+            + SingleModelEditStackData._writeSelectionsSize(this.afterCursorState)
+            + 4 // change count
+        );
+        for (const change of this.changes) {
+            necessarySize += change.writeSize();
+        }
+        const b = new Uint8Array(necessarySize);
+        let offset = 0;
+        writeUInt32BE(b, this.beforeVersionId, offset);
+        offset += 4;
+        writeUInt32BE(b, this.afterVersionId, offset);
+        offset += 4;
+        writeUInt8(b, this.beforeEOL, offset);
+        offset += 1;
+        writeUInt8(b, this.afterEOL, offset);
+        offset += 1;
+        offset = SingleModelEditStackData._writeSelections(b, this.beforeCursorState, offset);
+        offset = SingleModelEditStackData._writeSelections(b, this.afterCursorState, offset);
+        writeUInt32BE(b, this.changes.length, offset);
+        offset += 4;
+        for (const change of this.changes) {
+            offset = change.write(b, offset);
+        }
+        return b.buffer;
+    }
+    static deserialize(source) {
+        const b = new Uint8Array(source);
+        let offset = 0;
+        const beforeVersionId = readUInt32BE(b, offset);
+        offset += 4;
+        const afterVersionId = readUInt32BE(b, offset);
+        offset += 4;
+        const beforeEOL = readUInt8(b, offset);
+        offset += 1;
+        const afterEOL = readUInt8(b, offset);
+        offset += 1;
+        const beforeCursorState = [];
+        offset = SingleModelEditStackData._readSelections(b, offset, beforeCursorState);
+        const afterCursorState = [];
+        offset = SingleModelEditStackData._readSelections(b, offset, afterCursorState);
+        const changeCount = readUInt32BE(b, offset);
+        offset += 4;
+        const changes = [];
+        for (let i = 0; i < changeCount; i++) {
+            offset = TextChange.read(b, offset, changes);
+        }
+        return new SingleModelEditStackData(beforeVersionId, afterVersionId, beforeEOL, afterEOL, beforeCursorState, afterCursorState, changes);
+    }
+}
+class SingleModelEditStackElement {
+    get type() {
+        return 0 /* UndoRedoElementType.Resource */;
+    }
+    get resource() {
+        if (URI.isUri(this.model)) {
+            return this.model;
+        }
+        return this.model.uri;
+    }
+    constructor(label, code, model, beforeCursorState) {
+        this.label = label;
+        this.code = code;
+        this.model = model;
+        this._data = SingleModelEditStackData.create(model, beforeCursorState);
+    }
+    toString() {
+        const data = (this._data instanceof SingleModelEditStackData ? this._data : SingleModelEditStackData.deserialize(this._data));
+        return data.changes.map(change => change.toString()).join(', ');
+    }
+    matchesResource(resource) {
+        const uri = (URI.isUri(this.model) ? this.model : this.model.uri);
+        return (uri.toString() === resource.toString());
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    canAppend(model) {
+        return (this.model === model && this._data instanceof SingleModelEditStackData);
+    }
+    append(model, textChanges, afterEOL, afterVersionId, afterCursorState) {
+        if (this._data instanceof SingleModelEditStackData) {
+            this._data.append(model, textChanges, afterEOL, afterVersionId, afterCursorState);
+        }
+    }
+    close() {
+        if (this._data instanceof SingleModelEditStackData) {
+            this._data = this._data.serialize();
+        }
+    }
+    open() {
+        if (!(this._data instanceof SingleModelEditStackData)) {
+            this._data = SingleModelEditStackData.deserialize(this._data);
+        }
+    }
+    undo() {
+        if (URI.isUri(this.model)) {
+            // don't have a model
+            throw new Error(`Invalid SingleModelEditStackElement`);
+        }
+        if (this._data instanceof SingleModelEditStackData) {
+            this._data = this._data.serialize();
+        }
+        const data = SingleModelEditStackData.deserialize(this._data);
+        this.model._applyUndo(data.changes, data.beforeEOL, data.beforeVersionId, data.beforeCursorState);
+    }
+    redo() {
+        if (URI.isUri(this.model)) {
+            // don't have a model
+            throw new Error(`Invalid SingleModelEditStackElement`);
+        }
+        if (this._data instanceof SingleModelEditStackData) {
+            this._data = this._data.serialize();
+        }
+        const data = SingleModelEditStackData.deserialize(this._data);
+        this.model._applyRedo(data.changes, data.afterEOL, data.afterVersionId, data.afterCursorState);
+    }
+    heapSize() {
+        if (this._data instanceof SingleModelEditStackData) {
+            this._data = this._data.serialize();
+        }
+        return this._data.byteLength + 168 /*heap overhead*/;
+    }
+}
+class MultiModelEditStackElement {
+    get resources() {
+        return this._editStackElementsArr.map(editStackElement => editStackElement.resource);
+    }
+    constructor(label, code, editStackElements) {
+        this.label = label;
+        this.code = code;
+        this.type = 1 /* UndoRedoElementType.Workspace */;
+        this._isOpen = true;
+        this._editStackElementsArr = editStackElements.slice(0);
+        this._editStackElementsMap = new Map();
+        for (const editStackElement of this._editStackElementsArr) {
+            const key = uriGetComparisonKey(editStackElement.resource);
+            this._editStackElementsMap.set(key, editStackElement);
+        }
+        this._delegate = null;
+    }
+    prepareUndoRedo() {
+        if (this._delegate) {
+            return this._delegate.prepareUndoRedo(this);
+        }
+    }
+    matchesResource(resource) {
+        const key = uriGetComparisonKey(resource);
+        return (this._editStackElementsMap.has(key));
+    }
+    setModel(model) {
+        const key = uriGetComparisonKey(URI.isUri(model) ? model : model.uri);
+        if (this._editStackElementsMap.has(key)) {
+            this._editStackElementsMap.get(key).setModel(model);
+        }
+    }
+    canAppend(model) {
+        if (!this._isOpen) {
+            return false;
+        }
+        const key = uriGetComparisonKey(model.uri);
+        if (this._editStackElementsMap.has(key)) {
+            const editStackElement = this._editStackElementsMap.get(key);
+            return editStackElement.canAppend(model);
+        }
+        return false;
+    }
+    append(model, textChanges, afterEOL, afterVersionId, afterCursorState) {
+        const key = uriGetComparisonKey(model.uri);
+        const editStackElement = this._editStackElementsMap.get(key);
+        editStackElement.append(model, textChanges, afterEOL, afterVersionId, afterCursorState);
+    }
+    close() {
+        this._isOpen = false;
+    }
+    open() {
+        // cannot reopen
+    }
+    undo() {
+        this._isOpen = false;
+        for (const editStackElement of this._editStackElementsArr) {
+            editStackElement.undo();
+        }
+    }
+    redo() {
+        for (const editStackElement of this._editStackElementsArr) {
+            editStackElement.redo();
+        }
+    }
+    heapSize(resource) {
+        const key = uriGetComparisonKey(resource);
+        if (this._editStackElementsMap.has(key)) {
+            const editStackElement = this._editStackElementsMap.get(key);
+            return editStackElement.heapSize();
+        }
+        return 0;
+    }
+    split() {
+        return this._editStackElementsArr;
+    }
+    toString() {
+        const result = [];
+        for (const editStackElement of this._editStackElementsArr) {
+            result.push(`${basename(editStackElement.resource)}: ${editStackElement}`);
+        }
+        return `{${result.join(', ')}}`;
+    }
+}
+function getModelEOL(model) {
+    const eol = model.getEOL();
+    if (eol === '\n') {
+        return 0 /* EndOfLineSequence.LF */;
+    }
+    else {
+        return 1 /* EndOfLineSequence.CRLF */;
+    }
+}
+function isEditStackElement(element) {
+    if (!element) {
+        return false;
+    }
+    return ((element instanceof SingleModelEditStackElement) || (element instanceof MultiModelEditStackElement));
+}
+class EditStack {
+    constructor(model, undoRedoService) {
+        this._model = model;
+        this._undoRedoService = undoRedoService;
+    }
+    pushStackElement() {
+        const lastElement = this._undoRedoService.getLastElement(this._model.uri);
+        if (isEditStackElement(lastElement)) {
+            lastElement.close();
+        }
+    }
+    popStackElement() {
+        const lastElement = this._undoRedoService.getLastElement(this._model.uri);
+        if (isEditStackElement(lastElement)) {
+            lastElement.open();
+        }
+    }
+    clear() {
+        this._undoRedoService.removeElements(this._model.uri);
+    }
+    _getOrCreateEditStackElement(beforeCursorState, group) {
+        const lastElement = this._undoRedoService.getLastElement(this._model.uri);
+        if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
+            return lastElement;
+        }
+        const newElement = new SingleModelEditStackElement(localize(785, "Typing"), 'undoredo.textBufferEdit', this._model, beforeCursorState);
+        this._undoRedoService.pushElement(newElement, group);
+        return newElement;
+    }
+    pushEOL(eol) {
+        const editStackElement = this._getOrCreateEditStackElement(null, undefined);
+        this._model.setEOL(eol);
+        editStackElement.append(this._model, [], getModelEOL(this._model), this._model.getAlternativeVersionId(), null);
+    }
+    pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group, reason = EditSources.unknown({ name: 'pushEditOperation' })) {
+        const editStackElement = this._getOrCreateEditStackElement(beforeCursorState, group);
+        const inverseEditOperations = this._model.applyEdits(editOperations, true, reason);
+        const afterCursorState = EditStack._computeCursorState(cursorStateComputer, inverseEditOperations);
+        const textChanges = inverseEditOperations.map((op, index) => ({ index: index, textChange: op.textChange }));
+        textChanges.sort((a, b) => {
+            if (a.textChange.oldPosition === b.textChange.oldPosition) {
+                return a.index - b.index;
+            }
+            return a.textChange.oldPosition - b.textChange.oldPosition;
+        });
+        editStackElement.append(this._model, textChanges.map(op => op.textChange), getModelEOL(this._model), this._model.getAlternativeVersionId(), afterCursorState);
+        return afterCursorState;
+    }
+    static _computeCursorState(cursorStateComputer, inverseEditOperations) {
+        try {
+            return cursorStateComputer ? cursorStateComputer(inverseEditOperations) : null;
+        }
+        catch (e) {
+            onUnexpectedError(e);
+            return null;
+        }
+    }
+}
+
+export { EditStack, MultiModelEditStackElement, SingleModelEditStackData, SingleModelEditStackElement, isEditStackElement };

package/dist/workers/editor/common/editorAction.js

@@ -0,0 +1,26 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class InternalEditorAction {
+    constructor(id, label, alias, metadata, _precondition, _run, _contextKeyService) {
+        this.id = id;
+        this.label = label;
+        this.alias = alias;
+        this.metadata = metadata;
+        this._precondition = _precondition;
+        this._run = _run;
+        this._contextKeyService = _contextKeyService;
+    }
+    isSupported() {
+        return this._contextKeyService.contextMatchesRules(this._precondition);
+    }
+    run(args) {
+        if (!this.isSupported()) {
+            return Promise.resolve(undefined);
+        }
+        return this._run(args);
+    }
+}
+
+export { InternalEditorAction };

package/dist/workers/editor/common/editorBaseApi.js

@@ -0,0 +1,43 @@
+import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { Emitter } from '../../../base/common/event.js';
+import { KeyChord } from '../../../base/common/keyCodes.js';
+import { URI } from '../../../base/common/uri.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+import { Selection } from '../core/selection.js';
+import { Token } from '../languages.js';
+import { MarkerTag, MarkerSeverity, SelectionDirection, KeyCode } from '../standalone/standaloneEnums.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class KeyMod {
+    static { this.CtrlCmd = 2048 /* ConstKeyMod.CtrlCmd */; }
+    static { this.Shift = 1024 /* ConstKeyMod.Shift */; }
+    static { this.Alt = 512 /* ConstKeyMod.Alt */; }
+    static { this.WinCtrl = 256 /* ConstKeyMod.WinCtrl */; }
+    static chord(firstPart, secondPart) {
+        return KeyChord(firstPart, secondPart);
+    }
+}
+function createMonacoBaseAPI() {
+    return {
+        editor: undefined, // undefined override expected here
+        languages: undefined, // undefined override expected here
+        CancellationTokenSource: CancellationTokenSource,
+        Emitter: Emitter,
+        KeyCode: KeyCode,
+        KeyMod: KeyMod,
+        Position: Position,
+        Range: Range,
+        Selection: Selection,
+        SelectionDirection: SelectionDirection,
+        MarkerSeverity: MarkerSeverity,
+        MarkerTag: MarkerTag,
+        Uri: URI,
+        Token: Token
+    };
+}
+
+export { KeyMod, createMonacoBaseAPI };