monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,362 +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 TreeNode {
-    constructor(piece, color) {
-        this.piece = piece;
-        this.color = color;
-        this.size_left = 0;
-        this.lf_left = 0;
-        this.parent = this;
-        this.left = this;
-        this.right = this;
-    }
-    next() {
-        if (this.right !== SENTINEL) {
-            return leftest(this.right);
-        }
-        let node = this;
-        while (node.parent !== SENTINEL) {
-            if (node.parent.left === node) {
-                break;
-            }
-            node = node.parent;
-        }
-        if (node.parent === SENTINEL) {
-            return SENTINEL;
-        }
-        else {
-            return node.parent;
-        }
-    }
-    prev() {
-        if (this.left !== SENTINEL) {
-            return righttest(this.left);
-        }
-        let node = this;
-        while (node.parent !== SENTINEL) {
-            if (node.parent.right === node) {
-                break;
-            }
-            node = node.parent;
-        }
-        if (node.parent === SENTINEL) {
-            return SENTINEL;
-        }
-        else {
-            return node.parent;
-        }
-    }
-    detach() {
-        this.parent = null;
-        this.left = null;
-        this.right = null;
-    }
-}
-const SENTINEL = new TreeNode(null, 0 /* NodeColor.Black */);
-SENTINEL.parent = SENTINEL;
-SENTINEL.left = SENTINEL;
-SENTINEL.right = SENTINEL;
-SENTINEL.color = 0 /* NodeColor.Black */;
-function leftest(node) {
-    while (node.left !== SENTINEL) {
-        node = node.left;
-    }
-    return node;
-}
-function righttest(node) {
-    while (node.right !== SENTINEL) {
-        node = node.right;
-    }
-    return node;
-}
-function calculateSize(node) {
-    if (node === SENTINEL) {
-        return 0;
-    }
-    return node.size_left + node.piece.length + calculateSize(node.right);
-}
-function calculateLF(node) {
-    if (node === SENTINEL) {
-        return 0;
-    }
-    return node.lf_left + node.piece.lineFeedCnt + calculateLF(node.right);
-}
-function resetSentinel() {
-    SENTINEL.parent = SENTINEL;
-}
-function leftRotate(tree, x) {
-    const y = x.right;
-    // fix size_left
-    y.size_left += x.size_left + (x.piece ? x.piece.length : 0);
-    y.lf_left += x.lf_left + (x.piece ? x.piece.lineFeedCnt : 0);
-    x.right = y.left;
-    if (y.left !== SENTINEL) {
-        y.left.parent = x;
-    }
-    y.parent = x.parent;
-    if (x.parent === SENTINEL) {
-        tree.root = y;
-    }
-    else if (x.parent.left === x) {
-        x.parent.left = y;
-    }
-    else {
-        x.parent.right = y;
-    }
-    y.left = x;
-    x.parent = y;
-}
-function rightRotate(tree, y) {
-    const x = y.left;
-    y.left = x.right;
-    if (x.right !== SENTINEL) {
-        x.right.parent = y;
-    }
-    x.parent = y.parent;
-    // fix size_left
-    y.size_left -= x.size_left + (x.piece ? x.piece.length : 0);
-    y.lf_left -= x.lf_left + (x.piece ? x.piece.lineFeedCnt : 0);
-    if (y.parent === SENTINEL) {
-        tree.root = x;
-    }
-    else if (y === y.parent.right) {
-        y.parent.right = x;
-    }
-    else {
-        y.parent.left = x;
-    }
-    x.right = y;
-    y.parent = x;
-}
-function rbDelete(tree, z) {
-    let x;
-    let y;
-    if (z.left === SENTINEL) {
-        y = z;
-        x = y.right;
-    }
-    else if (z.right === SENTINEL) {
-        y = z;
-        x = y.left;
-    }
-    else {
-        y = leftest(z.right);
-        x = y.right;
-    }
-    if (y === tree.root) {
-        tree.root = x;
-        // if x is null, we are removing the only node
-        x.color = 0 /* NodeColor.Black */;
-        z.detach();
-        resetSentinel();
-        tree.root.parent = SENTINEL;
-        return;
-    }
-    const yWasRed = (y.color === 1 /* NodeColor.Red */);
-    if (y === y.parent.left) {
-        y.parent.left = x;
-    }
-    else {
-        y.parent.right = x;
-    }
-    if (y === z) {
-        x.parent = y.parent;
-        recomputeTreeMetadata(tree, x);
-    }
-    else {
-        if (y.parent === z) {
-            x.parent = y;
-        }
-        else {
-            x.parent = y.parent;
-        }
-        // as we make changes to x's hierarchy, update size_left of subtree first
-        recomputeTreeMetadata(tree, x);
-        y.left = z.left;
-        y.right = z.right;
-        y.parent = z.parent;
-        y.color = z.color;
-        if (z === tree.root) {
-            tree.root = y;
-        }
-        else {
-            if (z === z.parent.left) {
-                z.parent.left = y;
-            }
-            else {
-                z.parent.right = y;
-            }
-        }
-        if (y.left !== SENTINEL) {
-            y.left.parent = y;
-        }
-        if (y.right !== SENTINEL) {
-            y.right.parent = y;
-        }
-        // update metadata
-        // we replace z with y, so in this sub tree, the length change is z.item.length
-        y.size_left = z.size_left;
-        y.lf_left = z.lf_left;
-        recomputeTreeMetadata(tree, y);
-    }
-    z.detach();
-    if (x.parent.left === x) {
-        const newSizeLeft = calculateSize(x);
-        const newLFLeft = calculateLF(x);
-        if (newSizeLeft !== x.parent.size_left || newLFLeft !== x.parent.lf_left) {
-            const delta = newSizeLeft - x.parent.size_left;
-            const lf_delta = newLFLeft - x.parent.lf_left;
-            x.parent.size_left = newSizeLeft;
-            x.parent.lf_left = newLFLeft;
-            updateTreeMetadata(tree, x.parent, delta, lf_delta);
-        }
-    }
-    recomputeTreeMetadata(tree, x.parent);
-    if (yWasRed) {
-        resetSentinel();
-        return;
-    }
-    // RB-DELETE-FIXUP
-    let w;
-    while (x !== tree.root && x.color === 0 /* NodeColor.Black */) {
-        if (x === x.parent.left) {
-            w = x.parent.right;
-            if (w.color === 1 /* NodeColor.Red */) {
-                w.color = 0 /* NodeColor.Black */;
-                x.parent.color = 1 /* NodeColor.Red */;
-                leftRotate(tree, x.parent);
-                w = x.parent.right;
-            }
-            if (w.left.color === 0 /* NodeColor.Black */ && w.right.color === 0 /* NodeColor.Black */) {
-                w.color = 1 /* NodeColor.Red */;
-                x = x.parent;
-            }
-            else {
-                if (w.right.color === 0 /* NodeColor.Black */) {
-                    w.left.color = 0 /* NodeColor.Black */;
-                    w.color = 1 /* NodeColor.Red */;
-                    rightRotate(tree, w);
-                    w = x.parent.right;
-                }
-                w.color = x.parent.color;
-                x.parent.color = 0 /* NodeColor.Black */;
-                w.right.color = 0 /* NodeColor.Black */;
-                leftRotate(tree, x.parent);
-                x = tree.root;
-            }
-        }
-        else {
-            w = x.parent.left;
-            if (w.color === 1 /* NodeColor.Red */) {
-                w.color = 0 /* NodeColor.Black */;
-                x.parent.color = 1 /* NodeColor.Red */;
-                rightRotate(tree, x.parent);
-                w = x.parent.left;
-            }
-            if (w.left.color === 0 /* NodeColor.Black */ && w.right.color === 0 /* NodeColor.Black */) {
-                w.color = 1 /* NodeColor.Red */;
-                x = x.parent;
-            }
-            else {
-                if (w.left.color === 0 /* NodeColor.Black */) {
-                    w.right.color = 0 /* NodeColor.Black */;
-                    w.color = 1 /* NodeColor.Red */;
-                    leftRotate(tree, w);
-                    w = x.parent.left;
-                }
-                w.color = x.parent.color;
-                x.parent.color = 0 /* NodeColor.Black */;
-                w.left.color = 0 /* NodeColor.Black */;
-                rightRotate(tree, x.parent);
-                x = tree.root;
-            }
-        }
-    }
-    x.color = 0 /* NodeColor.Black */;
-    resetSentinel();
-}
-function fixInsert(tree, x) {
-    recomputeTreeMetadata(tree, x);
-    while (x !== tree.root && x.parent.color === 1 /* NodeColor.Red */) {
-        if (x.parent === x.parent.parent.left) {
-            const y = x.parent.parent.right;
-            if (y.color === 1 /* NodeColor.Red */) {
-                x.parent.color = 0 /* NodeColor.Black */;
-                y.color = 0 /* NodeColor.Black */;
-                x.parent.parent.color = 1 /* NodeColor.Red */;
-                x = x.parent.parent;
-            }
-            else {
-                if (x === x.parent.right) {
-                    x = x.parent;
-                    leftRotate(tree, x);
-                }
-                x.parent.color = 0 /* NodeColor.Black */;
-                x.parent.parent.color = 1 /* NodeColor.Red */;
-                rightRotate(tree, x.parent.parent);
-            }
-        }
-        else {
-            const y = x.parent.parent.left;
-            if (y.color === 1 /* NodeColor.Red */) {
-                x.parent.color = 0 /* NodeColor.Black */;
-                y.color = 0 /* NodeColor.Black */;
-                x.parent.parent.color = 1 /* NodeColor.Red */;
-                x = x.parent.parent;
-            }
-            else {
-                if (x === x.parent.left) {
-                    x = x.parent;
-                    rightRotate(tree, x);
-                }
-                x.parent.color = 0 /* NodeColor.Black */;
-                x.parent.parent.color = 1 /* NodeColor.Red */;
-                leftRotate(tree, x.parent.parent);
-            }
-        }
-    }
-    tree.root.color = 0 /* NodeColor.Black */;
-}
-function updateTreeMetadata(tree, x, delta, lineFeedCntDelta) {
-    // node length change or line feed count change
-    while (x !== tree.root && x !== SENTINEL) {
-        if (x.parent.left === x) {
-            x.parent.size_left += delta;
-            x.parent.lf_left += lineFeedCntDelta;
-        }
-        x = x.parent;
-    }
-}
-function recomputeTreeMetadata(tree, x) {
-    let delta = 0;
-    let lf_delta = 0;
-    if (x === tree.root) {
-        return;
-    }
-    // go upwards till the node whose left subtree is changed.
-    while (x !== tree.root && x === x.parent.right) {
-        x = x.parent;
-    }
-    if (x === tree.root) {
-        // well, it means we add a node to the end (inorder)
-        return;
-    }
-    // x is the node whose right subtree is changed.
-    x = x.parent;
-    delta = calculateSize(x.left) - x.size_left;
-    lf_delta = calculateLF(x.left) - x.lf_left;
-    x.size_left += delta;
-    x.lf_left += lf_delta;
-    // go upwards till root. O(logN)
-    while (x !== tree.root && (delta !== 0 || lf_delta !== 0)) {
-        if (x.parent.left === x) {
-            x.parent.size_left += delta;
-            x.parent.lf_left += lf_delta;
-        }
-        x = x.parent;
-    }
-}
-
-export { SENTINEL, TreeNode, fixInsert, leftRotate, leftest, rbDelete, recomputeTreeMetadata, rightRotate, righttest, updateTreeMetadata };

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

@@ -1,163 +0,0 @@
-import { BugIndicatingError } from '../../../../base/common/errors.js';
-import { Point } from './point.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class Rect {
-    static fromPoints(topLeft, bottomRight) {
-        return new Rect(topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
-    }
-    static fromPointSize(point, size) {
-        return new Rect(point.x, point.y, point.x + size.x, point.y + size.y);
-    }
-    static fromLeftTopRightBottom(left, top, right, bottom) {
-        return new Rect(left, top, right, bottom);
-    }
-    static fromLeftTopWidthHeight(left, top, width, height) {
-        return new Rect(left, top, left + width, top + height);
-    }
-    static fromRanges(leftRight, topBottom) {
-        return new Rect(leftRight.start, topBottom.start, leftRight.endExclusive, topBottom.endExclusive);
-    }
-    static hull(rects) {
-        let left = Number.MAX_SAFE_INTEGER;
-        let top = Number.MAX_SAFE_INTEGER;
-        let right = Number.MIN_SAFE_INTEGER;
-        let bottom = Number.MIN_SAFE_INTEGER;
-        for (const rect of rects) {
-            left = Math.min(left, rect.left);
-            top = Math.min(top, rect.top);
-            right = Math.max(right, rect.right);
-            bottom = Math.max(bottom, rect.bottom);
-        }
-        return new Rect(left, top, right, bottom);
-    }
-    get width() { return this.right - this.left; }
-    get height() { return this.bottom - this.top; }
-    constructor(left, top, right, bottom) {
-        this.left = left;
-        this.top = top;
-        this.right = right;
-        this.bottom = bottom;
-        if (left > right) {
-            throw new BugIndicatingError('Invalid arguments: Horizontally offset by ' + (left - right));
-        }
-        if (top > bottom) {
-            throw new BugIndicatingError('Invalid arguments: Vertically offset by ' + (top - bottom));
-        }
-    }
-    withMargin(marginOrVerticalOrTop, rightOrHorizontal, bottom, left) {
-        let marginLeft, marginRight, marginTop, marginBottom;
-        // Single margin value
-        if (rightOrHorizontal === undefined && bottom === undefined && left === undefined) {
-            marginLeft = marginRight = marginTop = marginBottom = marginOrVerticalOrTop;
-        }
-        // Vertical and horizontal margins
-        else if (bottom === undefined && left === undefined) {
-            marginLeft = marginRight = rightOrHorizontal;
-            marginTop = marginBottom = marginOrVerticalOrTop;
-        }
-        // Individual margins for all sides
-        else {
-            marginLeft = left;
-            marginRight = rightOrHorizontal;
-            marginTop = marginOrVerticalOrTop;
-            marginBottom = bottom;
-        }
-        return new Rect(this.left - marginLeft, this.top - marginTop, this.right + marginRight, this.bottom + marginBottom);
-    }
-    intersectVertical(range) {
-        const newTop = Math.max(this.top, range.start);
-        const newBottom = Math.min(this.bottom, range.endExclusive);
-        return new Rect(this.left, newTop, this.right, Math.max(newTop, newBottom));
-    }
-    intersectHorizontal(range) {
-        const newLeft = Math.max(this.left, range.start);
-        const newRight = Math.min(this.right, range.endExclusive);
-        return new Rect(newLeft, this.top, Math.max(newLeft, newRight), this.bottom);
-    }
-    toString() {
-        return `Rect{(${this.left},${this.top}), (${this.right},${this.bottom})}`;
-    }
-    intersect(parent) {
-        const left = Math.max(this.left, parent.left);
-        const right = Math.min(this.right, parent.right);
-        const top = Math.max(this.top, parent.top);
-        const bottom = Math.min(this.bottom, parent.bottom);
-        if (left > right || top > bottom) {
-            return undefined;
-        }
-        return new Rect(left, top, right, bottom);
-    }
-    containsRect(other) {
-        return this.left <= other.left
-            && this.top <= other.top
-            && this.right >= other.right
-            && this.bottom >= other.bottom;
-    }
-    containsPoint(point) {
-        return this.left <= point.x
-            && this.top <= point.y
-            && this.right >= point.x
-            && this.bottom >= point.y;
-    }
-    moveToBeContainedIn(parent) {
-        const width = this.width;
-        const height = this.height;
-        let left = this.left;
-        let top = this.top;
-        if (left < parent.left) {
-            left = parent.left;
-        }
-        else if (left + width > parent.right) {
-            left = parent.right - width;
-        }
-        if (top < parent.top) {
-            top = parent.top;
-        }
-        else if (top + height > parent.bottom) {
-            top = parent.bottom - height;
-        }
-        return new Rect(left, top, left + width, top + height);
-    }
-    withWidth(width) {
-        return new Rect(this.left, this.top, this.left + width, this.bottom);
-    }
-    withHeight(height) {
-        return new Rect(this.left, this.top, this.right, this.top + height);
-    }
-    withTop(top) {
-        return new Rect(this.left, top, this.right, this.bottom);
-    }
-    withLeft(left) {
-        return new Rect(left, this.top, this.right, this.bottom);
-    }
-    translateX(delta) {
-        return new Rect(this.left + delta, this.top, this.right + delta, this.bottom);
-    }
-    translateY(delta) {
-        return new Rect(this.left, this.top + delta, this.right, this.bottom + delta);
-    }
-    getLeftBottom() {
-        return new Point(this.left, this.bottom);
-    }
-    getRightBottom() {
-        return new Point(this.right, this.bottom);
-    }
-    getRightTop() {
-        return new Point(this.right, this.top);
-    }
-    toStyles() {
-        return {
-            position: 'absolute',
-            left: `${this.left}px`,
-            top: `${this.top}px`,
-            width: `${this.width}px`,
-            height: `${this.height}px`,
-        };
-    }
-}
-
-export { Rect };

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

@@ -1,158 +0,0 @@
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-import { Selection } from '../core/selection.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ReplaceCommand {
-    constructor(range, text, insertsAutoWhitespace = false) {
-        this._range = range;
-        this._text = text;
-        this.insertsAutoWhitespace = insertsAutoWhitespace;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(this._range, this._text);
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const srcRange = inverseEditOperations[0].range;
-        return Selection.fromPositions(srcRange.getEndPosition());
-    }
-}
-class ReplaceOvertypeCommand {
-    constructor(range, text, insertsAutoWhitespace = false) {
-        this._range = range;
-        this._text = text;
-        this.insertsAutoWhitespace = insertsAutoWhitespace;
-    }
-    getEditOperations(model, builder) {
-        const intialStartPosition = this._range.getStartPosition();
-        const initialEndPosition = this._range.getEndPosition();
-        const initialEndLineNumber = initialEndPosition.lineNumber;
-        const offsetDelta = this._text.length + (this._range.isEmpty() ? 0 : -1);
-        let endPosition = addPositiveOffsetToModelPosition(model, initialEndPosition, offsetDelta);
-        if (endPosition.lineNumber > initialEndLineNumber) {
-            endPosition = new Position(initialEndLineNumber, model.getLineMaxColumn(initialEndLineNumber));
-        }
-        const replaceRange = Range.fromPositions(intialStartPosition, endPosition);
-        builder.addTrackedEditOperation(replaceRange, this._text);
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const srcRange = inverseEditOperations[0].range;
-        return Selection.fromPositions(srcRange.getEndPosition());
-    }
-}
-class ReplaceCommandThatSelectsText {
-    constructor(range, text) {
-        this._range = range;
-        this._text = text;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(this._range, this._text);
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const srcRange = inverseEditOperations[0].range;
-        return Selection.fromRange(srcRange, 0 /* SelectionDirection.LTR */);
-    }
-}
-class ReplaceCommandWithoutChangingPosition {
-    constructor(range, text, insertsAutoWhitespace = false) {
-        this._range = range;
-        this._text = text;
-        this.insertsAutoWhitespace = insertsAutoWhitespace;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(this._range, this._text);
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const srcRange = inverseEditOperations[0].range;
-        return Selection.fromPositions(srcRange.getStartPosition());
-    }
-}
-class ReplaceCommandWithOffsetCursorState {
-    constructor(range, text, lineNumberDeltaOffset, columnDeltaOffset, insertsAutoWhitespace = false) {
-        this._range = range;
-        this._text = text;
-        this._columnDeltaOffset = columnDeltaOffset;
-        this._lineNumberDeltaOffset = lineNumberDeltaOffset;
-        this.insertsAutoWhitespace = insertsAutoWhitespace;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(this._range, this._text);
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const srcRange = inverseEditOperations[0].range;
-        return Selection.fromPositions(srcRange.getEndPosition().delta(this._lineNumberDeltaOffset, this._columnDeltaOffset));
-    }
-}
-class ReplaceOvertypeCommandOnCompositionEnd {
-    constructor(range) {
-        this._range = range;
-    }
-    getEditOperations(model, builder) {
-        const text = model.getValueInRange(this._range);
-        const initialEndPosition = this._range.getEndPosition();
-        const initialEndLineNumber = initialEndPosition.lineNumber;
-        let endPosition = addPositiveOffsetToModelPosition(model, initialEndPosition, text.length);
-        if (endPosition.lineNumber > initialEndLineNumber) {
-            endPosition = new Position(initialEndLineNumber, model.getLineMaxColumn(initialEndLineNumber));
-        }
-        const replaceRange = Range.fromPositions(initialEndPosition, endPosition);
-        builder.addTrackedEditOperation(replaceRange, '');
-    }
-    computeCursorState(model, helper) {
-        const inverseEditOperations = helper.getInverseEditOperations();
-        const srcRange = inverseEditOperations[0].range;
-        return Selection.fromPositions(srcRange.getEndPosition());
-    }
-}
-class ReplaceCommandThatPreservesSelection {
-    constructor(editRange, text, initialSelection, forceMoveMarkers = false) {
-        this._range = editRange;
-        this._text = text;
-        this._initialSelection = initialSelection;
-        this._forceMoveMarkers = forceMoveMarkers;
-        this._selectionId = null;
-    }
-    getEditOperations(model, builder) {
-        builder.addTrackedEditOperation(this._range, this._text, this._forceMoveMarkers);
-        this._selectionId = builder.trackSelection(this._initialSelection);
-    }
-    computeCursorState(model, helper) {
-        return helper.getTrackedSelection(this._selectionId);
-    }
-}
-function addPositiveOffsetToModelPosition(model, position, offset) {
-    if (offset < 0) {
-        throw new Error('Unexpected negative delta');
-    }
-    const lineCount = model.getLineCount();
-    let endPosition = new Position(lineCount, model.getLineMaxColumn(lineCount));
-    for (let lineNumber = position.lineNumber; lineNumber <= lineCount; lineNumber++) {
-        if (lineNumber === position.lineNumber) {
-            const futureOffset = offset - model.getLineMaxColumn(position.lineNumber) + position.column;
-            if (futureOffset <= 0) {
-                endPosition = new Position(position.lineNumber, position.column + offset);
-                break;
-            }
-            offset = futureOffset;
-        }
-        else {
-            const futureOffset = offset - model.getLineMaxColumn(lineNumber);
-            if (futureOffset <= 0) {
-                endPosition = new Position(lineNumber, offset);
-                break;
-            }
-            offset = futureOffset;
-        }
-    }
-    return endPosition;
-}
-
-export { ReplaceCommand, ReplaceCommandThatPreservesSelection, ReplaceCommandThatSelectsText, ReplaceCommandWithOffsetCursorState, ReplaceCommandWithoutChangingPosition, ReplaceOvertypeCommand, ReplaceOvertypeCommandOnCompositionEnd };

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

@@ -1,5 +0,0 @@
-import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
-
-const ITextModelService = createDecorator('textModelService');
-
-export { ITextModelService };