monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,183 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,363 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,43 +0,0 @@
-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 };