Upload folder using huggingface_hub (part 15)

.gitattributes

@@ -56,3 +56,5 @@ node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node filter=l
 node_modules/lightningcss-linux-x64-musl/lightningcss.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text
 node_modules/monaco-editor/dev/vs/editor/editor.main.js.map filter=lfs diff=lfs merge=lfs -text
 node_modules/monaco-editor/dev/vs/language/typescript/tsWorker.js filter=lfs diff=lfs merge=lfs -text
+node_modules/monaco-editor/esm/vs/language/typescript/ts.worker.js filter=lfs diff=lfs merge=lfs -text
+node_modules/monaco-editor/min-maps/vs/editor/editor.main.js.map filter=lfs diff=lfs merge=lfs -text

node_modules/monaco-editor/esm/vs/editor/common/model.js

@@ -0,0 +1,133 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { equals } from '../../base/common/objects.js';
+/**
+ * Vertical Lane in the overview ruler of the editor.
+ */
+export var OverviewRulerLane;
+(function (OverviewRulerLane) {
+    OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";
+    OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";
+    OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";
+    OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";
+})(OverviewRulerLane || (OverviewRulerLane = {}));
+/**
+ * Vertical Lane in the glyph margin of the editor.
+ */
+export var GlyphMarginLane;
+(function (GlyphMarginLane) {
+    GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left";
+    GlyphMarginLane[GlyphMarginLane["Center"] = 2] = "Center";
+    GlyphMarginLane[GlyphMarginLane["Right"] = 3] = "Right";
+})(GlyphMarginLane || (GlyphMarginLane = {}));
+export var InjectedTextCursorStops;
+(function (InjectedTextCursorStops) {
+    InjectedTextCursorStops[InjectedTextCursorStops["Both"] = 0] = "Both";
+    InjectedTextCursorStops[InjectedTextCursorStops["Right"] = 1] = "Right";
+    InjectedTextCursorStops[InjectedTextCursorStops["Left"] = 2] = "Left";
+    InjectedTextCursorStops[InjectedTextCursorStops["None"] = 3] = "None";
+})(InjectedTextCursorStops || (InjectedTextCursorStops = {}));
+export class TextModelResolvedOptions {
+    get originalIndentSize() {
+        return this._indentSizeIsTabSize ? 'tabSize' : this.indentSize;
+    }
+    /**
+     * @internal
+     */
+    constructor(src) {
+        this._textModelResolvedOptionsBrand = undefined;
+        this.tabSize = Math.max(1, src.tabSize | 0);
+        if (src.indentSize === 'tabSize') {
+            this.indentSize = this.tabSize;
+            this._indentSizeIsTabSize = true;
+        }
+        else {
+            this.indentSize = Math.max(1, src.indentSize | 0);
+            this._indentSizeIsTabSize = false;
+        }
+        this.insertSpaces = Boolean(src.insertSpaces);
+        this.defaultEOL = src.defaultEOL | 0;
+        this.trimAutoWhitespace = Boolean(src.trimAutoWhitespace);
+        this.bracketPairColorizationOptions = src.bracketPairColorizationOptions;
+    }
+    /**
+     * @internal
+     */
+    equals(other) {
+        return (this.tabSize === other.tabSize
+            && this._indentSizeIsTabSize === other._indentSizeIsTabSize
+            && this.indentSize === other.indentSize
+            && this.insertSpaces === other.insertSpaces
+            && this.defaultEOL === other.defaultEOL
+            && this.trimAutoWhitespace === other.trimAutoWhitespace
+            && equals(this.bracketPairColorizationOptions, other.bracketPairColorizationOptions));
+    }
+    /**
+     * @internal
+     */
+    createChangeEvent(newOpts) {
+        return {
+            tabSize: this.tabSize !== newOpts.tabSize,
+            indentSize: this.indentSize !== newOpts.indentSize,
+            insertSpaces: this.insertSpaces !== newOpts.insertSpaces,
+            trimAutoWhitespace: this.trimAutoWhitespace !== newOpts.trimAutoWhitespace,
+        };
+    }
+}
+export class FindMatch {
+    /**
+     * @internal
+     */
+    constructor(range, matches) {
+        this._findMatchBrand = undefined;
+        this.range = range;
+        this.matches = matches;
+    }
+}
+/**
+ * @internal
+ */
+export function isITextSnapshot(obj) {
+    return (obj && typeof obj.read === 'function');
+}
+/**
+ * @internal
+ */
+export class ValidAnnotatedEditOperation {
+    constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) {
+        this.identifier = identifier;
+        this.range = range;
+        this.text = text;
+        this.forceMoveMarkers = forceMoveMarkers;
+        this.isAutoWhitespaceEdit = isAutoWhitespaceEdit;
+        this._isTracked = _isTracked;
+    }
+}
+/**
+ * @internal
+ */
+export class SearchData {
+    constructor(regex, wordSeparators, simpleSearch) {
+        this.regex = regex;
+        this.wordSeparators = wordSeparators;
+        this.simpleSearch = simpleSearch;
+    }
+}
+/**
+ * @internal
+ */
+export class ApplyEditsResult {
+    constructor(reverseEdits, changes, trimAutoWhitespaceLineNumbers) {
+        this.reverseEdits = reverseEdits;
+        this.changes = changes;
+        this.trimAutoWhitespaceLineNumbers = trimAutoWhitespaceLineNumbers;
+    }
+}
+/**
+ * @internal
+ */
+export function shouldSynchronizeModel(model) {
+    return (!model.isTooLargeForSyncing() && !model.isForSimpleWidget);
+}

node_modules/monaco-editor/esm/vs/editor/common/model/decorationProvider.js

@@ -0,0 +1 @@
+export {};

node_modules/monaco-editor/esm/vs/editor/common/model/editStack.js

@@ -0,0 +1,359 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as nls from '../../../nls.js';
+import { onUnexpectedError } from '../../../base/common/errors.js';
+import { Selection } from '../core/selection.js';
+import { URI } from '../../../base/common/uri.js';
+import { TextChange, compressConsecutiveTextChanges } from '../core/textChange.js';
+import * as buffer from '../../../base/common/buffer.js';
+import { basename } from '../../../base/common/resources.js';
+function uriGetComparisonKey(resource) {
+    return resource.toString();
+}
+export 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) {
+        buffer.writeUInt32BE(b, (selections ? selections.length : 0), offset);
+        offset += 4;
+        if (selections) {
+            for (const selection of selections) {
+                buffer.writeUInt32BE(b, selection.selectionStartLineNumber, offset);
+                offset += 4;
+                buffer.writeUInt32BE(b, selection.selectionStartColumn, offset);
+                offset += 4;
+                buffer.writeUInt32BE(b, selection.positionLineNumber, offset);
+                offset += 4;
+                buffer.writeUInt32BE(b, selection.positionColumn, offset);
+                offset += 4;
+            }
+        }
+        return offset;
+    }
+    static _readSelections(b, offset, dest) {
+        const count = buffer.readUInt32BE(b, offset);
+        offset += 4;
+        for (let i = 0; i < count; i++) {
+            const selectionStartLineNumber = buffer.readUInt32BE(b, offset);
+            offset += 4;
+            const selectionStartColumn = buffer.readUInt32BE(b, offset);
+            offset += 4;
+            const positionLineNumber = buffer.readUInt32BE(b, offset);
+            offset += 4;
+            const positionColumn = buffer.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;
+        buffer.writeUInt32BE(b, this.beforeVersionId, offset);
+        offset += 4;
+        buffer.writeUInt32BE(b, this.afterVersionId, offset);
+        offset += 4;
+        buffer.writeUInt8(b, this.beforeEOL, offset);
+        offset += 1;
+        buffer.writeUInt8(b, this.afterEOL, offset);
+        offset += 1;
+        offset = SingleModelEditStackData._writeSelections(b, this.beforeCursorState, offset);
+        offset = SingleModelEditStackData._writeSelections(b, this.afterCursorState, offset);
+        buffer.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 = buffer.readUInt32BE(b, offset);
+        offset += 4;
+        const afterVersionId = buffer.readUInt32BE(b, offset);
+        offset += 4;
+        const beforeEOL = buffer.readUInt8(b, offset);
+        offset += 1;
+        const afterEOL = buffer.readUInt8(b, offset);
+        offset += 1;
+        const beforeCursorState = [];
+        offset = SingleModelEditStackData._readSelections(b, offset, beforeCursorState);
+        const afterCursorState = [];
+        offset = SingleModelEditStackData._readSelections(b, offset, afterCursorState);
+        const changeCount = buffer.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);
+    }
+}
+export 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*/;
+    }
+}
+export 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 */;
+    }
+}
+export function isEditStackElement(element) {
+    if (!element) {
+        return false;
+    }
+    return ((element instanceof SingleModelEditStackElement) || (element instanceof MultiModelEditStackElement));
+}
+export 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(nls.localize('edit', "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) {
+        const editStackElement = this._getOrCreateEditStackElement(beforeCursorState, group);
+        const inverseEditOperations = this._model.applyEdits(editOperations, true);
+        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;
+        }
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/fixedArray.js

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { arrayInsert } from '../../../base/common/arrays.js';
+/**
+ * An array that avoids being sparse by always
+ * filling up unused indices with a default value.
+ */
+export class FixedArray {
+    constructor(_default) {
+        this._default = _default;
+        this._store = [];
+    }
+    get(index) {
+        if (index < this._store.length) {
+            return this._store[index];
+        }
+        return this._default;
+    }
+    set(index, value) {
+        while (index >= this._store.length) {
+            this._store[this._store.length] = this._default;
+        }
+        this._store[index] = value;
+    }
+    replace(index, oldLength, newLength) {
+        if (index >= this._store.length) {
+            return;
+        }
+        if (oldLength === 0) {
+            this.insert(index, newLength);
+            return;
+        }
+        else if (newLength === 0) {
+            this.delete(index, oldLength);
+            return;
+        }
+        const before = this._store.slice(0, index);
+        const after = this._store.slice(index + oldLength);
+        const insertArr = arrayFill(newLength, this._default);
+        this._store = before.concat(insertArr, after);
+    }
+    delete(deleteIndex, deleteCount) {
+        if (deleteCount === 0 || deleteIndex >= this._store.length) {
+            return;
+        }
+        this._store.splice(deleteIndex, deleteCount);
+    }
+    insert(insertIndex, insertCount) {
+        if (insertCount === 0 || insertIndex >= this._store.length) {
+            return;
+        }
+        const arr = [];
+        for (let i = 0; i < insertCount; i++) {
+            arr[i] = this._default;
+        }
+        this._store = arrayInsert(this._store, insertIndex, arr);
+    }
+}
+function arrayFill(length, value) {
+    const arr = [];
+    for (let i = 0; i < length; i++) {
+        arr[i] = value;
+    }
+    return arr;
+}

node_modules/monaco-editor/esm/vs/editor/common/model/guidesTextModelPart.js

@@ -0,0 +1,402 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { findLast } from '../../../base/common/arraysFind.js';
+import * as strings from '../../../base/common/strings.js';
+import { CursorColumns } from '../core/cursorColumns.js';
+import { Range } from '../core/range.js';
+import { TextModelPart } from './textModelPart.js';
+import { computeIndentLevel } from './utils.js';
+import { HorizontalGuidesState, IndentGuide, IndentGuideHorizontalLine } from '../textModelGuides.js';
+import { BugIndicatingError } from '../../../base/common/errors.js';
+export class GuidesTextModelPart extends TextModelPart {
+    constructor(textModel, languageConfigurationService) {
+        super();
+        this.textModel = textModel;
+        this.languageConfigurationService = languageConfigurationService;
+    }
+    getLanguageConfiguration(languageId) {
+        return this.languageConfigurationService.getLanguageConfiguration(languageId);
+    }
+    _computeIndentLevel(lineIndex) {
+        return computeIndentLevel(this.textModel.getLineContent(lineIndex + 1), this.textModel.getOptions().tabSize);
+    }
+    getActiveIndentGuide(lineNumber, minLineNumber, maxLineNumber) {
+        this.assertNotDisposed();
+        const lineCount = this.textModel.getLineCount();
+        if (lineNumber < 1 || lineNumber > lineCount) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+        const foldingRules = this.getLanguageConfiguration(this.textModel.getLanguageId()).foldingRules;
+        const offSide = Boolean(foldingRules && foldingRules.offSide);
+        let up_aboveContentLineIndex = -2; /* -2 is a marker for not having computed it */
+        let up_aboveContentLineIndent = -1;
+        let up_belowContentLineIndex = -2; /* -2 is a marker for not having computed it */
+        let up_belowContentLineIndent = -1;
+        const up_resolveIndents = (lineNumber) => {
+            if (up_aboveContentLineIndex !== -1 &&
+                (up_aboveContentLineIndex === -2 ||
+                    up_aboveContentLineIndex > lineNumber - 1)) {
+                up_aboveContentLineIndex = -1;
+                up_aboveContentLineIndent = -1;
+                // must find previous line with content
+                for (let lineIndex = lineNumber - 2; lineIndex >= 0; lineIndex--) {
+                    const indent = this._computeIndentLevel(lineIndex);
+                    if (indent >= 0) {
+                        up_aboveContentLineIndex = lineIndex;
+                        up_aboveContentLineIndent = indent;
+                        break;
+                    }
+                }
+            }
+            if (up_belowContentLineIndex === -2) {
+                up_belowContentLineIndex = -1;
+                up_belowContentLineIndent = -1;
+                // must find next line with content
+                for (let lineIndex = lineNumber; lineIndex < lineCount; lineIndex++) {
+                    const indent = this._computeIndentLevel(lineIndex);
+                    if (indent >= 0) {
+                        up_belowContentLineIndex = lineIndex;
+                        up_belowContentLineIndent = indent;
+                        break;
+                    }
+                }
+            }
+        };
+        let down_aboveContentLineIndex = -2; /* -2 is a marker for not having computed it */
+        let down_aboveContentLineIndent = -1;
+        let down_belowContentLineIndex = -2; /* -2 is a marker for not having computed it */
+        let down_belowContentLineIndent = -1;
+        const down_resolveIndents = (lineNumber) => {
+            if (down_aboveContentLineIndex === -2) {
+                down_aboveContentLineIndex = -1;
+                down_aboveContentLineIndent = -1;
+                // must find previous line with content
+                for (let lineIndex = lineNumber - 2; lineIndex >= 0; lineIndex--) {
+                    const indent = this._computeIndentLevel(lineIndex);
+                    if (indent >= 0) {
+                        down_aboveContentLineIndex = lineIndex;
+                        down_aboveContentLineIndent = indent;
+                        break;
+                    }
+                }
+            }
+            if (down_belowContentLineIndex !== -1 &&
+                (down_belowContentLineIndex === -2 ||
+                    down_belowContentLineIndex < lineNumber - 1)) {
+                down_belowContentLineIndex = -1;
+                down_belowContentLineIndent = -1;
+                // must find next line with content
+                for (let lineIndex = lineNumber; lineIndex < lineCount; lineIndex++) {
+                    const indent = this._computeIndentLevel(lineIndex);
+                    if (indent >= 0) {
+                        down_belowContentLineIndex = lineIndex;
+                        down_belowContentLineIndent = indent;
+                        break;
+                    }
+                }
+            }
+        };
+        let startLineNumber = 0;
+        let goUp = true;
+        let endLineNumber = 0;
+        let goDown = true;
+        let indent = 0;
+        let initialIndent = 0;
+        for (let distance = 0; goUp || goDown; distance++) {
+            const upLineNumber = lineNumber - distance;
+            const downLineNumber = lineNumber + distance;
+            if (distance > 1 && (upLineNumber < 1 || upLineNumber < minLineNumber)) {
+                goUp = false;
+            }
+            if (distance > 1 &&
+                (downLineNumber > lineCount || downLineNumber > maxLineNumber)) {
+                goDown = false;
+            }
+            if (distance > 50000) {
+                // stop processing
+                goUp = false;
+                goDown = false;
+            }
+            let upLineIndentLevel = -1;
+            if (goUp && upLineNumber >= 1) {
+                // compute indent level going up
+                const currentIndent = this._computeIndentLevel(upLineNumber - 1);
+                if (currentIndent >= 0) {
+                    // This line has content (besides whitespace)
+                    // Use the line's indent
+                    up_belowContentLineIndex = upLineNumber - 1;
+                    up_belowContentLineIndent = currentIndent;
+                    upLineIndentLevel = Math.ceil(currentIndent / this.textModel.getOptions().indentSize);
+                }
+                else {
+                    up_resolveIndents(upLineNumber);
+                    upLineIndentLevel = this._getIndentLevelForWhitespaceLine(offSide, up_aboveContentLineIndent, up_belowContentLineIndent);
+                }
+            }
+            let downLineIndentLevel = -1;
+            if (goDown && downLineNumber <= lineCount) {
+                // compute indent level going down
+                const currentIndent = this._computeIndentLevel(downLineNumber - 1);
+                if (currentIndent >= 0) {
+                    // This line has content (besides whitespace)
+                    // Use the line's indent
+                    down_aboveContentLineIndex = downLineNumber - 1;
+                    down_aboveContentLineIndent = currentIndent;
+                    downLineIndentLevel = Math.ceil(currentIndent / this.textModel.getOptions().indentSize);
+                }
+                else {
+                    down_resolveIndents(downLineNumber);
+                    downLineIndentLevel = this._getIndentLevelForWhitespaceLine(offSide, down_aboveContentLineIndent, down_belowContentLineIndent);
+                }
+            }
+            if (distance === 0) {
+                initialIndent = upLineIndentLevel;
+                continue;
+            }
+            if (distance === 1) {
+                if (downLineNumber <= lineCount &&
+                    downLineIndentLevel >= 0 &&
+                    initialIndent + 1 === downLineIndentLevel) {
+                    // This is the beginning of a scope, we have special handling here, since we want the
+                    // child scope indent to be active, not the parent scope
+                    goUp = false;
+                    startLineNumber = downLineNumber;
+                    endLineNumber = downLineNumber;
+                    indent = downLineIndentLevel;
+                    continue;
+                }
+                if (upLineNumber >= 1 &&
+                    upLineIndentLevel >= 0 &&
+                    upLineIndentLevel - 1 === initialIndent) {
+                    // This is the end of a scope, just like above
+                    goDown = false;
+                    startLineNumber = upLineNumber;
+                    endLineNumber = upLineNumber;
+                    indent = upLineIndentLevel;
+                    continue;
+                }
+                startLineNumber = lineNumber;
+                endLineNumber = lineNumber;
+                indent = initialIndent;
+                if (indent === 0) {
+                    // No need to continue
+                    return { startLineNumber, endLineNumber, indent };
+                }
+            }
+            if (goUp) {
+                if (upLineIndentLevel >= indent) {
+                    startLineNumber = upLineNumber;
+                }
+                else {
+                    goUp = false;
+                }
+            }
+            if (goDown) {
+                if (downLineIndentLevel >= indent) {
+                    endLineNumber = downLineNumber;
+                }
+                else {
+                    goDown = false;
+                }
+            }
+        }
+        return { startLineNumber, endLineNumber, indent };
+    }
+    getLinesBracketGuides(startLineNumber, endLineNumber, activePosition, options) {
+        const result = [];
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            result.push([]);
+        }
+        // If requested, this could be made configurable.
+        const includeSingleLinePairs = true;
+        const bracketPairs = this.textModel.bracketPairs.getBracketPairsInRangeWithMinIndentation(new Range(startLineNumber, 1, endLineNumber, this.textModel.getLineMaxColumn(endLineNumber))).toArray();
+        let activeBracketPairRange = undefined;
+        if (activePosition && bracketPairs.length > 0) {
+            const bracketsContainingActivePosition = (startLineNumber <= activePosition.lineNumber &&
+                activePosition.lineNumber <= endLineNumber
+                // We don't need to query the brackets again if the cursor is in the viewport
+                ? bracketPairs
+                : this.textModel.bracketPairs.getBracketPairsInRange(Range.fromPositions(activePosition)).toArray()).filter((bp) => Range.strictContainsPosition(bp.range, activePosition));
+            activeBracketPairRange = findLast(bracketsContainingActivePosition, (i) => includeSingleLinePairs || i.range.startLineNumber !== i.range.endLineNumber)?.range;
+        }
+        const independentColorPoolPerBracketType = this.textModel.getOptions().bracketPairColorizationOptions.independentColorPoolPerBracketType;
+        const colorProvider = new BracketPairGuidesClassNames();
+        for (const pair of bracketPairs) {
+            /*
+
+
+                    {
+                    |
+                    }
+
+                    {
+                    |
+                    ----}
+
+                ____{
+                |test
+                ----}
+
+                renderHorizontalEndLineAtTheBottom:
+                    {
+                    |
+                    |x}
+                    --
+                renderHorizontalEndLineAtTheBottom:
+                ____{
+                |test
+                | x }
+                ----
+            */
+            if (!pair.closingBracketRange) {
+                continue;
+            }
+            const isActive = activeBracketPairRange && pair.range.equalsRange(activeBracketPairRange);
+            if (!isActive && !options.includeInactive) {
+                continue;
+            }
+            const className = colorProvider.getInlineClassName(pair.nestingLevel, pair.nestingLevelOfEqualBracketType, independentColorPoolPerBracketType) +
+                (options.highlightActive && isActive
+                    ? ' ' + colorProvider.activeClassName
+                    : '');
+            const start = pair.openingBracketRange.getStartPosition();
+            const end = pair.closingBracketRange.getStartPosition();
+            const horizontalGuides = options.horizontalGuides === HorizontalGuidesState.Enabled || (options.horizontalGuides === HorizontalGuidesState.EnabledForActive && isActive);
+            if (pair.range.startLineNumber === pair.range.endLineNumber) {
+                if (includeSingleLinePairs && horizontalGuides) {
+                    result[pair.range.startLineNumber - startLineNumber].push(new IndentGuide(-1, pair.openingBracketRange.getEndPosition().column, className, new IndentGuideHorizontalLine(false, end.column), -1, -1));
+                }
+                continue;
+            }
+            const endVisibleColumn = this.getVisibleColumnFromPosition(end);
+            const startVisibleColumn = this.getVisibleColumnFromPosition(pair.openingBracketRange.getStartPosition());
+            const guideVisibleColumn = Math.min(startVisibleColumn, endVisibleColumn, pair.minVisibleColumnIndentation + 1);
+            let renderHorizontalEndLineAtTheBottom = false;
+            const firstNonWsIndex = strings.firstNonWhitespaceIndex(this.textModel.getLineContent(pair.closingBracketRange.startLineNumber));
+            const hasTextBeforeClosingBracket = firstNonWsIndex < pair.closingBracketRange.startColumn - 1;
+            if (hasTextBeforeClosingBracket) {
+                renderHorizontalEndLineAtTheBottom = true;
+            }
+            const visibleGuideStartLineNumber = Math.max(start.lineNumber, startLineNumber);
+            const visibleGuideEndLineNumber = Math.min(end.lineNumber, endLineNumber);
+            const offset = renderHorizontalEndLineAtTheBottom ? 1 : 0;
+            for (let l = visibleGuideStartLineNumber; l < visibleGuideEndLineNumber + offset; l++) {
+                result[l - startLineNumber].push(new IndentGuide(guideVisibleColumn, -1, className, null, l === start.lineNumber ? start.column : -1, l === end.lineNumber ? end.column : -1));
+            }
+            if (horizontalGuides) {
+                if (start.lineNumber >= startLineNumber && startVisibleColumn > guideVisibleColumn) {
+                    result[start.lineNumber - startLineNumber].push(new IndentGuide(guideVisibleColumn, -1, className, new IndentGuideHorizontalLine(false, start.column), -1, -1));
+                }
+                if (end.lineNumber <= endLineNumber && endVisibleColumn > guideVisibleColumn) {
+                    result[end.lineNumber - startLineNumber].push(new IndentGuide(guideVisibleColumn, -1, className, new IndentGuideHorizontalLine(!renderHorizontalEndLineAtTheBottom, end.column), -1, -1));
+                }
+            }
+        }
+        for (const guides of result) {
+            guides.sort((a, b) => a.visibleColumn - b.visibleColumn);
+        }
+        return result;
+    }
+    getVisibleColumnFromPosition(position) {
+        return (CursorColumns.visibleColumnFromColumn(this.textModel.getLineContent(position.lineNumber), position.column, this.textModel.getOptions().tabSize) + 1);
+    }
+    getLinesIndentGuides(startLineNumber, endLineNumber) {
+        this.assertNotDisposed();
+        const lineCount = this.textModel.getLineCount();
+        if (startLineNumber < 1 || startLineNumber > lineCount) {
+            throw new Error('Illegal value for startLineNumber');
+        }
+        if (endLineNumber < 1 || endLineNumber > lineCount) {
+            throw new Error('Illegal value for endLineNumber');
+        }
+        const options = this.textModel.getOptions();
+        const foldingRules = this.getLanguageConfiguration(this.textModel.getLanguageId()).foldingRules;
+        const offSide = Boolean(foldingRules && foldingRules.offSide);
+        const result = new Array(endLineNumber - startLineNumber + 1);
+        let aboveContentLineIndex = -2; /* -2 is a marker for not having computed it */
+        let aboveContentLineIndent = -1;
+        let belowContentLineIndex = -2; /* -2 is a marker for not having computed it */
+        let belowContentLineIndent = -1;
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const resultIndex = lineNumber - startLineNumber;
+            const currentIndent = this._computeIndentLevel(lineNumber - 1);
+            if (currentIndent >= 0) {
+                // This line has content (besides whitespace)
+                // Use the line's indent
+                aboveContentLineIndex = lineNumber - 1;
+                aboveContentLineIndent = currentIndent;
+                result[resultIndex] = Math.ceil(currentIndent / options.indentSize);
+                continue;
+            }
+            if (aboveContentLineIndex === -2) {
+                aboveContentLineIndex = -1;
+                aboveContentLineIndent = -1;
+                // must find previous line with content
+                for (let lineIndex = lineNumber - 2; lineIndex >= 0; lineIndex--) {
+                    const indent = this._computeIndentLevel(lineIndex);
+                    if (indent >= 0) {
+                        aboveContentLineIndex = lineIndex;
+                        aboveContentLineIndent = indent;
+                        break;
+                    }
+                }
+            }
+            if (belowContentLineIndex !== -1 &&
+                (belowContentLineIndex === -2 || belowContentLineIndex < lineNumber - 1)) {
+                belowContentLineIndex = -1;
+                belowContentLineIndent = -1;
+                // must find next line with content
+                for (let lineIndex = lineNumber; lineIndex < lineCount; lineIndex++) {
+                    const indent = this._computeIndentLevel(lineIndex);
+                    if (indent >= 0) {
+                        belowContentLineIndex = lineIndex;
+                        belowContentLineIndent = indent;
+                        break;
+                    }
+                }
+            }
+            result[resultIndex] = this._getIndentLevelForWhitespaceLine(offSide, aboveContentLineIndent, belowContentLineIndent);
+        }
+        return result;
+    }
+    _getIndentLevelForWhitespaceLine(offSide, aboveContentLineIndent, belowContentLineIndent) {
+        const options = this.textModel.getOptions();
+        if (aboveContentLineIndent === -1 || belowContentLineIndent === -1) {
+            // At the top or bottom of the file
+            return 0;
+        }
+        else if (aboveContentLineIndent < belowContentLineIndent) {
+            // we are inside the region above
+            return 1 + Math.floor(aboveContentLineIndent / options.indentSize);
+        }
+        else if (aboveContentLineIndent === belowContentLineIndent) {
+            // we are in between two regions
+            return Math.ceil(belowContentLineIndent / options.indentSize);
+        }
+        else {
+            if (offSide) {
+                // same level as region below
+                return Math.ceil(belowContentLineIndent / options.indentSize);
+            }
+            else {
+                // we are inside the region that ends below
+                return 1 + Math.floor(belowContentLineIndent / options.indentSize);
+            }
+        }
+    }
+}
+export class BracketPairGuidesClassNames {
+    constructor() {
+        this.activeClassName = 'indent-active';
+    }
+    getInlineClassName(nestingLevel, nestingLevelOfEqualBracketType, independentColorPoolPerBracketType) {
+        return this.getInlineClassNameOfLevel(independentColorPoolPerBracketType ? nestingLevelOfEqualBracketType : nestingLevel);
+    }
+    getInlineClassNameOfLevel(level) {
+        // To support a dynamic amount of colors up to 6 colors,
+        // we use a number that is a lcm of all numbers from 1 to 6.
+        return `bracket-indent-guide lvl-${level % 30}`;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/indentationGuesser.js

@@ -0,0 +1,176 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class SpacesDiffResult {
+    constructor() {
+        this.spacesDiff = 0;
+        this.looksLikeAlignment = false;
+    }
+}
+/**
+ * Compute the diff in spaces between two line's indentation.
+ */
+function spacesDiff(a, aLength, b, bLength, result) {
+    result.spacesDiff = 0;
+    result.looksLikeAlignment = false;
+    // This can go both ways (e.g.):
+    //  - a: "\t"
+    //  - b: "\t    "
+    //  => This should count 1 tab and 4 spaces
+    let i;
+    for (i = 0; i < aLength && i < bLength; i++) {
+        const aCharCode = a.charCodeAt(i);
+        const bCharCode = b.charCodeAt(i);
+        if (aCharCode !== bCharCode) {
+            break;
+        }
+    }
+    let aSpacesCnt = 0, aTabsCount = 0;
+    for (let j = i; j < aLength; j++) {
+        const aCharCode = a.charCodeAt(j);
+        if (aCharCode === 32 /* CharCode.Space */) {
+            aSpacesCnt++;
+        }
+        else {
+            aTabsCount++;
+        }
+    }
+    let bSpacesCnt = 0, bTabsCount = 0;
+    for (let j = i; j < bLength; j++) {
+        const bCharCode = b.charCodeAt(j);
+        if (bCharCode === 32 /* CharCode.Space */) {
+            bSpacesCnt++;
+        }
+        else {
+            bTabsCount++;
+        }
+    }
+    if (aSpacesCnt > 0 && aTabsCount > 0) {
+        return;
+    }
+    if (bSpacesCnt > 0 && bTabsCount > 0) {
+        return;
+    }
+    const tabsDiff = Math.abs(aTabsCount - bTabsCount);
+    const spacesDiff = Math.abs(aSpacesCnt - bSpacesCnt);
+    if (tabsDiff === 0) {
+        // check if the indentation difference might be caused by alignment reasons
+        // sometime folks like to align their code, but this should not be used as a hint
+        result.spacesDiff = spacesDiff;
+        if (spacesDiff > 0 && 0 <= bSpacesCnt - 1 && bSpacesCnt - 1 < a.length && bSpacesCnt < b.length) {
+            if (b.charCodeAt(bSpacesCnt) !== 32 /* CharCode.Space */ && a.charCodeAt(bSpacesCnt - 1) === 32 /* CharCode.Space */) {
+                if (a.charCodeAt(a.length - 1) === 44 /* CharCode.Comma */) {
+                    // This looks like an alignment desire: e.g.
+                    // const a = b + c,
+                    //       d = b - c;
+                    result.looksLikeAlignment = true;
+                }
+            }
+        }
+        return;
+    }
+    if (spacesDiff % tabsDiff === 0) {
+        result.spacesDiff = spacesDiff / tabsDiff;
+        return;
+    }
+}
+export function guessIndentation(source, defaultTabSize, defaultInsertSpaces) {
+    // Look at most at the first 10k lines
+    const linesCount = Math.min(source.getLineCount(), 10000);
+    let linesIndentedWithTabsCount = 0; // number of lines that contain at least one tab in indentation
+    let linesIndentedWithSpacesCount = 0; // number of lines that contain only spaces in indentation
+    let previousLineText = ''; // content of latest line that contained non-whitespace chars
+    let previousLineIndentation = 0; // index at which latest line contained the first non-whitespace char
+    const ALLOWED_TAB_SIZE_GUESSES = [2, 4, 6, 8, 3, 5, 7]; // prefer even guesses for `tabSize`, limit to [2, 8].
+    const MAX_ALLOWED_TAB_SIZE_GUESS = 8; // max(ALLOWED_TAB_SIZE_GUESSES) = 8
+    const spacesDiffCount = [0, 0, 0, 0, 0, 0, 0, 0, 0]; // `tabSize` scores
+    const tmp = new SpacesDiffResult();
+    for (let lineNumber = 1; lineNumber <= linesCount; lineNumber++) {
+        const currentLineLength = source.getLineLength(lineNumber);
+        const currentLineText = source.getLineContent(lineNumber);
+        // if the text buffer is chunk based, so long lines are cons-string, v8 will flattern the string when we check charCode.
+        // checking charCode on chunks directly is cheaper.
+        const useCurrentLineText = (currentLineLength <= 65536);
+        let currentLineHasContent = false; // does `currentLineText` contain non-whitespace chars
+        let currentLineIndentation = 0; // index at which `currentLineText` contains the first non-whitespace char
+        let currentLineSpacesCount = 0; // count of spaces found in `currentLineText` indentation
+        let currentLineTabsCount = 0; // count of tabs found in `currentLineText` indentation
+        for (let j = 0, lenJ = currentLineLength; j < lenJ; j++) {
+            const charCode = (useCurrentLineText ? currentLineText.charCodeAt(j) : source.getLineCharCode(lineNumber, j));
+            if (charCode === 9 /* CharCode.Tab */) {
+                currentLineTabsCount++;
+            }
+            else if (charCode === 32 /* CharCode.Space */) {
+                currentLineSpacesCount++;
+            }
+            else {
+                // Hit non whitespace character on this line
+                currentLineHasContent = true;
+                currentLineIndentation = j;
+                break;
+            }
+        }
+        // Ignore empty or only whitespace lines
+        if (!currentLineHasContent) {
+            continue;
+        }
+        if (currentLineTabsCount > 0) {
+            linesIndentedWithTabsCount++;
+        }
+        else if (currentLineSpacesCount > 1) {
+            linesIndentedWithSpacesCount++;
+        }
+        spacesDiff(previousLineText, previousLineIndentation, currentLineText, currentLineIndentation, tmp);
+        if (tmp.looksLikeAlignment) {
+            // if defaultInsertSpaces === true && the spaces count == tabSize, we may want to count it as valid indentation
+            //
+            // - item1
+            //   - item2
+            //
+            // otherwise skip this line entirely
+            //
+            // const a = 1,
+            //       b = 2;
+            if (!(defaultInsertSpaces && defaultTabSize === tmp.spacesDiff)) {
+                continue;
+            }
+        }
+        const currentSpacesDiff = tmp.spacesDiff;
+        if (currentSpacesDiff <= MAX_ALLOWED_TAB_SIZE_GUESS) {
+            spacesDiffCount[currentSpacesDiff]++;
+        }
+        previousLineText = currentLineText;
+        previousLineIndentation = currentLineIndentation;
+    }
+    let insertSpaces = defaultInsertSpaces;
+    if (linesIndentedWithTabsCount !== linesIndentedWithSpacesCount) {
+        insertSpaces = (linesIndentedWithTabsCount < linesIndentedWithSpacesCount);
+    }
+    let tabSize = defaultTabSize;
+    // Guess tabSize only if inserting spaces...
+    if (insertSpaces) {
+        let tabSizeScore = (insertSpaces ? 0 : 0.1 * linesCount);
+        // console.log("score threshold: " + tabSizeScore);
+        ALLOWED_TAB_SIZE_GUESSES.forEach((possibleTabSize) => {
+            const possibleTabSizeScore = spacesDiffCount[possibleTabSize];
+            if (possibleTabSizeScore > tabSizeScore) {
+                tabSizeScore = possibleTabSizeScore;
+                tabSize = possibleTabSize;
+            }
+        });
+        // Let a tabSize of 2 win even if it is not the maximum
+        // (only in case 4 was guessed)
+        if (tabSize === 4 && spacesDiffCount[4] > 0 && spacesDiffCount[2] > 0 && spacesDiffCount[2] >= spacesDiffCount[4] / 2) {
+            tabSize = 2;
+        }
+    }
+    // console.log('--------------------------');
+    // console.log('linesIndentedWithTabsCount: ' + linesIndentedWithTabsCount + ', linesIndentedWithSpacesCount: ' + linesIndentedWithSpacesCount);
+    // console.log('spacesDiffCount: ' + spacesDiffCount);
+    // console.log('tabSize: ' + tabSize + ', tabSizeScore: ' + tabSizeScore);
+    return {
+        insertSpaces: insertSpaces,
+        tabSize: tabSize
+    };
+}

node_modules/monaco-editor/esm/vs/editor/common/model/intervalTree.js

@@ -0,0 +1,986 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export function getNodeColor(node) {
+    return ((node.metadata & 1 /* Constants.ColorMask */) >>> 0 /* Constants.ColorOffset */);
+}
+function setNodeColor(node, color) {
+    node.metadata = ((node.metadata & 254 /* Constants.ColorMaskInverse */) | (color << 0 /* Constants.ColorOffset */));
+}
+function getNodeIsVisited(node) {
+    return ((node.metadata & 2 /* Constants.IsVisitedMask */) >>> 1 /* Constants.IsVisitedOffset */) === 1;
+}
+function setNodeIsVisited(node, value) {
+    node.metadata = ((node.metadata & 253 /* Constants.IsVisitedMaskInverse */) | ((value ? 1 : 0) << 1 /* Constants.IsVisitedOffset */));
+}
+function getNodeIsForValidation(node) {
+    return ((node.metadata & 4 /* Constants.IsForValidationMask */) >>> 2 /* Constants.IsForValidationOffset */) === 1;
+}
+function setNodeIsForValidation(node, value) {
+    node.metadata = ((node.metadata & 251 /* Constants.IsForValidationMaskInverse */) | ((value ? 1 : 0) << 2 /* Constants.IsForValidationOffset */));
+}
+function getNodeIsInGlyphMargin(node) {
+    return ((node.metadata & 64 /* Constants.IsMarginMask */) >>> 6 /* Constants.IsMarginOffset */) === 1;
+}
+function setNodeIsInGlyphMargin(node, value) {
+    node.metadata = ((node.metadata & 191 /* Constants.IsMarginMaskInverse */) | ((value ? 1 : 0) << 6 /* Constants.IsMarginOffset */));
+}
+function getNodeStickiness(node) {
+    return ((node.metadata & 24 /* Constants.StickinessMask */) >>> 3 /* Constants.StickinessOffset */);
+}
+function _setNodeStickiness(node, stickiness) {
+    node.metadata = ((node.metadata & 231 /* Constants.StickinessMaskInverse */) | (stickiness << 3 /* Constants.StickinessOffset */));
+}
+function getCollapseOnReplaceEdit(node) {
+    return ((node.metadata & 32 /* Constants.CollapseOnReplaceEditMask */) >>> 5 /* Constants.CollapseOnReplaceEditOffset */) === 1;
+}
+function setCollapseOnReplaceEdit(node, value) {
+    node.metadata = ((node.metadata & 223 /* Constants.CollapseOnReplaceEditMaskInverse */) | ((value ? 1 : 0) << 5 /* Constants.CollapseOnReplaceEditOffset */));
+}
+export class IntervalNode {
+    constructor(id, start, end) {
+        this.metadata = 0;
+        this.parent = this;
+        this.left = this;
+        this.right = this;
+        setNodeColor(this, 1 /* NodeColor.Red */);
+        this.start = start;
+        this.end = end;
+        // FORCE_OVERFLOWING_TEST: this.delta = start;
+        this.delta = 0;
+        this.maxEnd = end;
+        this.id = id;
+        this.ownerId = 0;
+        this.options = null;
+        setNodeIsForValidation(this, false);
+        setNodeIsInGlyphMargin(this, false);
+        _setNodeStickiness(this, 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */);
+        setCollapseOnReplaceEdit(this, false);
+        this.cachedVersionId = 0;
+        this.cachedAbsoluteStart = start;
+        this.cachedAbsoluteEnd = end;
+        this.range = null;
+        setNodeIsVisited(this, false);
+    }
+    reset(versionId, start, end, range) {
+        this.start = start;
+        this.end = end;
+        this.maxEnd = end;
+        this.cachedVersionId = versionId;
+        this.cachedAbsoluteStart = start;
+        this.cachedAbsoluteEnd = end;
+        this.range = range;
+    }
+    setOptions(options) {
+        this.options = options;
+        const className = this.options.className;
+        setNodeIsForValidation(this, (className === "squiggly-error" /* ClassName.EditorErrorDecoration */
+            || className === "squiggly-warning" /* ClassName.EditorWarningDecoration */
+            || className === "squiggly-info" /* ClassName.EditorInfoDecoration */));
+        setNodeIsInGlyphMargin(this, this.options.glyphMarginClassName !== null);
+        _setNodeStickiness(this, this.options.stickiness);
+        setCollapseOnReplaceEdit(this, this.options.collapseOnReplaceEdit);
+    }
+    setCachedOffsets(absoluteStart, absoluteEnd, cachedVersionId) {
+        if (this.cachedVersionId !== cachedVersionId) {
+            this.range = null;
+        }
+        this.cachedVersionId = cachedVersionId;
+        this.cachedAbsoluteStart = absoluteStart;
+        this.cachedAbsoluteEnd = absoluteEnd;
+    }
+    detach() {
+        this.parent = null;
+        this.left = null;
+        this.right = null;
+    }
+}
+export const SENTINEL = new IntervalNode(null, 0, 0);
+SENTINEL.parent = SENTINEL;
+SENTINEL.left = SENTINEL;
+SENTINEL.right = SENTINEL;
+setNodeColor(SENTINEL, 0 /* NodeColor.Black */);
+export class IntervalTree {
+    constructor() {
+        this.root = SENTINEL;
+        this.requestNormalizeDelta = false;
+    }
+    intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+        if (this.root === SENTINEL) {
+            return [];
+        }
+        return intervalSearch(this, start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+    }
+    search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+        if (this.root === SENTINEL) {
+            return [];
+        }
+        return search(this, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+    }
+    /**
+     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!
+     */
+    collectNodesFromOwner(ownerId) {
+        return collectNodesFromOwner(this, ownerId);
+    }
+    /**
+     * Will not set `cachedAbsoluteStart` nor `cachedAbsoluteEnd` on the returned nodes!
+     */
+    collectNodesPostOrder() {
+        return collectNodesPostOrder(this);
+    }
+    insert(node) {
+        rbTreeInsert(this, node);
+        this._normalizeDeltaIfNecessary();
+    }
+    delete(node) {
+        rbTreeDelete(this, node);
+        this._normalizeDeltaIfNecessary();
+    }
+    resolveNode(node, cachedVersionId) {
+        const initialNode = node;
+        let delta = 0;
+        while (node !== this.root) {
+            if (node === node.parent.right) {
+                delta += node.parent.delta;
+            }
+            node = node.parent;
+        }
+        const nodeStart = initialNode.start + delta;
+        const nodeEnd = initialNode.end + delta;
+        initialNode.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);
+    }
+    acceptReplace(offset, length, textLength, forceMoveMarkers) {
+        // Our strategy is to remove all directly impacted nodes, and then add them back to the tree.
+        // (1) collect all nodes that are intersecting this edit as nodes of interest
+        const nodesOfInterest = searchForEditing(this, offset, offset + length);
+        // (2) remove all nodes that are intersecting this edit
+        for (let i = 0, len = nodesOfInterest.length; i < len; i++) {
+            const node = nodesOfInterest[i];
+            rbTreeDelete(this, node);
+        }
+        this._normalizeDeltaIfNecessary();
+        // (3) edit all tree nodes except the nodes of interest
+        noOverlapReplace(this, offset, offset + length, textLength);
+        this._normalizeDeltaIfNecessary();
+        // (4) edit the nodes of interest and insert them back in the tree
+        for (let i = 0, len = nodesOfInterest.length; i < len; i++) {
+            const node = nodesOfInterest[i];
+            node.start = node.cachedAbsoluteStart;
+            node.end = node.cachedAbsoluteEnd;
+            nodeAcceptEdit(node, offset, (offset + length), textLength, forceMoveMarkers);
+            node.maxEnd = node.end;
+            rbTreeInsert(this, node);
+        }
+        this._normalizeDeltaIfNecessary();
+    }
+    _normalizeDeltaIfNecessary() {
+        if (!this.requestNormalizeDelta) {
+            return;
+        }
+        this.requestNormalizeDelta = false;
+        normalizeDelta(this);
+    }
+}
+//#region Delta Normalization
+function normalizeDelta(T) {
+    let node = T.root;
+    let delta = 0;
+    while (node !== SENTINEL) {
+        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
+            // go left
+            node = node.left;
+            continue;
+        }
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            delta += node.delta;
+            node = node.right;
+            continue;
+        }
+        // handle current node
+        node.start = delta + node.start;
+        node.end = delta + node.end;
+        node.delta = 0;
+        recomputeMaxEnd(node);
+        setNodeIsVisited(node, true);
+        // going up from this node
+        setNodeIsVisited(node.left, false);
+        setNodeIsVisited(node.right, false);
+        if (node === node.parent.right) {
+            delta -= node.parent.delta;
+        }
+        node = node.parent;
+    }
+    setNodeIsVisited(T.root, false);
+}
+function adjustMarkerBeforeColumn(markerOffset, markerStickToPreviousCharacter, checkOffset, moveSemantics) {
+    if (markerOffset < checkOffset) {
+        return true;
+    }
+    if (markerOffset > checkOffset) {
+        return false;
+    }
+    if (moveSemantics === 1 /* MarkerMoveSemantics.ForceMove */) {
+        return false;
+    }
+    if (moveSemantics === 2 /* MarkerMoveSemantics.ForceStay */) {
+        return true;
+    }
+    return markerStickToPreviousCharacter;
+}
+/**
+ * This is a lot more complicated than strictly necessary to maintain the same behaviour
+ * as when decorations were implemented using two markers.
+ */
+export function nodeAcceptEdit(node, start, end, textLength, forceMoveMarkers) {
+    const nodeStickiness = getNodeStickiness(node);
+    const startStickToPreviousCharacter = (nodeStickiness === 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */
+        || nodeStickiness === 2 /* TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */);
+    const endStickToPreviousCharacter = (nodeStickiness === 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */
+        || nodeStickiness === 2 /* TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */);
+    const deletingCnt = (end - start);
+    const insertingCnt = textLength;
+    const commonLength = Math.min(deletingCnt, insertingCnt);
+    const nodeStart = node.start;
+    let startDone = false;
+    const nodeEnd = node.end;
+    let endDone = false;
+    if (start <= nodeStart && nodeEnd <= end && getCollapseOnReplaceEdit(node)) {
+        // This edit encompasses the entire decoration range
+        // and the decoration has asked to become collapsed
+        node.start = start;
+        startDone = true;
+        node.end = start;
+        endDone = true;
+    }
+    {
+        const moveSemantics = forceMoveMarkers ? 1 /* MarkerMoveSemantics.ForceMove */ : (deletingCnt > 0 ? 2 /* MarkerMoveSemantics.ForceStay */ : 0 /* MarkerMoveSemantics.MarkerDefined */);
+        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start, moveSemantics)) {
+            startDone = true;
+        }
+        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, start, moveSemantics)) {
+            endDone = true;
+        }
+    }
+    if (commonLength > 0 && !forceMoveMarkers) {
+        const moveSemantics = (deletingCnt > insertingCnt ? 2 /* MarkerMoveSemantics.ForceStay */ : 0 /* MarkerMoveSemantics.MarkerDefined */);
+        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, start + commonLength, moveSemantics)) {
+            startDone = true;
+        }
+        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, start + commonLength, moveSemantics)) {
+            endDone = true;
+        }
+    }
+    {
+        const moveSemantics = forceMoveMarkers ? 1 /* MarkerMoveSemantics.ForceMove */ : 0 /* MarkerMoveSemantics.MarkerDefined */;
+        if (!startDone && adjustMarkerBeforeColumn(nodeStart, startStickToPreviousCharacter, end, moveSemantics)) {
+            node.start = start + insertingCnt;
+            startDone = true;
+        }
+        if (!endDone && adjustMarkerBeforeColumn(nodeEnd, endStickToPreviousCharacter, end, moveSemantics)) {
+            node.end = start + insertingCnt;
+            endDone = true;
+        }
+    }
+    // Finish
+    const deltaColumn = (insertingCnt - deletingCnt);
+    if (!startDone) {
+        node.start = Math.max(0, nodeStart + deltaColumn);
+    }
+    if (!endDone) {
+        node.end = Math.max(0, nodeEnd + deltaColumn);
+    }
+    if (node.start > node.end) {
+        node.end = node.start;
+    }
+}
+function searchForEditing(T, start, end) {
+    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree
+    // Now, it is known that two intervals A and B overlap only when both
+    // A.low <= B.high and A.high >= B.low. When searching the trees for
+    // nodes overlapping with a given interval, you can immediately skip:
+    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.
+    //  b) all nodes that have their maximum 'high' value below the start of the given interval.
+    let node = T.root;
+    let delta = 0;
+    let nodeMaxEnd = 0;
+    let nodeStart = 0;
+    let nodeEnd = 0;
+    const result = [];
+    let resultLen = 0;
+    while (node !== SENTINEL) {
+        if (getNodeIsVisited(node)) {
+            // going up from this node
+            setNodeIsVisited(node.left, false);
+            setNodeIsVisited(node.right, false);
+            if (node === node.parent.right) {
+                delta -= node.parent.delta;
+            }
+            node = node.parent;
+            continue;
+        }
+        if (!getNodeIsVisited(node.left)) {
+            // first time seeing this node
+            nodeMaxEnd = delta + node.maxEnd;
+            if (nodeMaxEnd < start) {
+                // cover case b) from above
+                // there is no need to search this node or its children
+                setNodeIsVisited(node, true);
+                continue;
+            }
+            if (node.left !== SENTINEL) {
+                // go left
+                node = node.left;
+                continue;
+            }
+        }
+        // handle current node
+        nodeStart = delta + node.start;
+        if (nodeStart > end) {
+            // cover case a) from above
+            // there is no need to search this node or its right subtree
+            setNodeIsVisited(node, true);
+            continue;
+        }
+        nodeEnd = delta + node.end;
+        if (nodeEnd >= start) {
+            node.setCachedOffsets(nodeStart, nodeEnd, 0);
+            result[resultLen++] = node;
+        }
+        setNodeIsVisited(node, true);
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            delta += node.delta;
+            node = node.right;
+            continue;
+        }
+    }
+    setNodeIsVisited(T.root, false);
+    return result;
+}
+function noOverlapReplace(T, start, end, textLength) {
+    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree
+    // Now, it is known that two intervals A and B overlap only when both
+    // A.low <= B.high and A.high >= B.low. When searching the trees for
+    // nodes overlapping with a given interval, you can immediately skip:
+    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.
+    //  b) all nodes that have their maximum 'high' value below the start of the given interval.
+    let node = T.root;
+    let delta = 0;
+    let nodeMaxEnd = 0;
+    let nodeStart = 0;
+    const editDelta = (textLength - (end - start));
+    while (node !== SENTINEL) {
+        if (getNodeIsVisited(node)) {
+            // going up from this node
+            setNodeIsVisited(node.left, false);
+            setNodeIsVisited(node.right, false);
+            if (node === node.parent.right) {
+                delta -= node.parent.delta;
+            }
+            recomputeMaxEnd(node);
+            node = node.parent;
+            continue;
+        }
+        if (!getNodeIsVisited(node.left)) {
+            // first time seeing this node
+            nodeMaxEnd = delta + node.maxEnd;
+            if (nodeMaxEnd < start) {
+                // cover case b) from above
+                // there is no need to search this node or its children
+                setNodeIsVisited(node, true);
+                continue;
+            }
+            if (node.left !== SENTINEL) {
+                // go left
+                node = node.left;
+                continue;
+            }
+        }
+        // handle current node
+        nodeStart = delta + node.start;
+        if (nodeStart > end) {
+            node.start += editDelta;
+            node.end += editDelta;
+            node.delta += editDelta;
+            if (node.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || node.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
+                T.requestNormalizeDelta = true;
+            }
+            // cover case a) from above
+            // there is no need to search this node or its right subtree
+            setNodeIsVisited(node, true);
+            continue;
+        }
+        setNodeIsVisited(node, true);
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            delta += node.delta;
+            node = node.right;
+            continue;
+        }
+    }
+    setNodeIsVisited(T.root, false);
+}
+//#endregion
+//#region Searching
+function collectNodesFromOwner(T, ownerId) {
+    let node = T.root;
+    const result = [];
+    let resultLen = 0;
+    while (node !== SENTINEL) {
+        if (getNodeIsVisited(node)) {
+            // going up from this node
+            setNodeIsVisited(node.left, false);
+            setNodeIsVisited(node.right, false);
+            node = node.parent;
+            continue;
+        }
+        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
+            // go left
+            node = node.left;
+            continue;
+        }
+        // handle current node
+        if (node.ownerId === ownerId) {
+            result[resultLen++] = node;
+        }
+        setNodeIsVisited(node, true);
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            node = node.right;
+            continue;
+        }
+    }
+    setNodeIsVisited(T.root, false);
+    return result;
+}
+function collectNodesPostOrder(T) {
+    let node = T.root;
+    const result = [];
+    let resultLen = 0;
+    while (node !== SENTINEL) {
+        if (getNodeIsVisited(node)) {
+            // going up from this node
+            setNodeIsVisited(node.left, false);
+            setNodeIsVisited(node.right, false);
+            node = node.parent;
+            continue;
+        }
+        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
+            // go left
+            node = node.left;
+            continue;
+        }
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            node = node.right;
+            continue;
+        }
+        // handle current node
+        result[resultLen++] = node;
+        setNodeIsVisited(node, true);
+    }
+    setNodeIsVisited(T.root, false);
+    return result;
+}
+function search(T, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+    let node = T.root;
+    let delta = 0;
+    let nodeStart = 0;
+    let nodeEnd = 0;
+    const result = [];
+    let resultLen = 0;
+    while (node !== SENTINEL) {
+        if (getNodeIsVisited(node)) {
+            // going up from this node
+            setNodeIsVisited(node.left, false);
+            setNodeIsVisited(node.right, false);
+            if (node === node.parent.right) {
+                delta -= node.parent.delta;
+            }
+            node = node.parent;
+            continue;
+        }
+        if (node.left !== SENTINEL && !getNodeIsVisited(node.left)) {
+            // go left
+            node = node.left;
+            continue;
+        }
+        // handle current node
+        nodeStart = delta + node.start;
+        nodeEnd = delta + node.end;
+        node.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);
+        let include = true;
+        if (filterOwnerId && node.ownerId && node.ownerId !== filterOwnerId) {
+            include = false;
+        }
+        if (filterOutValidation && getNodeIsForValidation(node)) {
+            include = false;
+        }
+        if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {
+            include = false;
+        }
+        if (include) {
+            result[resultLen++] = node;
+        }
+        setNodeIsVisited(node, true);
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            delta += node.delta;
+            node = node.right;
+            continue;
+        }
+    }
+    setNodeIsVisited(T.root, false);
+    return result;
+}
+function intervalSearch(T, intervalStart, intervalEnd, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+    // https://en.wikipedia.org/wiki/Interval_tree#Augmented_tree
+    // Now, it is known that two intervals A and B overlap only when both
+    // A.low <= B.high and A.high >= B.low. When searching the trees for
+    // nodes overlapping with a given interval, you can immediately skip:
+    //  a) all nodes to the right of nodes whose low value is past the end of the given interval.
+    //  b) all nodes that have their maximum 'high' value below the start of the given interval.
+    let node = T.root;
+    let delta = 0;
+    let nodeMaxEnd = 0;
+    let nodeStart = 0;
+    let nodeEnd = 0;
+    const result = [];
+    let resultLen = 0;
+    while (node !== SENTINEL) {
+        if (getNodeIsVisited(node)) {
+            // going up from this node
+            setNodeIsVisited(node.left, false);
+            setNodeIsVisited(node.right, false);
+            if (node === node.parent.right) {
+                delta -= node.parent.delta;
+            }
+            node = node.parent;
+            continue;
+        }
+        if (!getNodeIsVisited(node.left)) {
+            // first time seeing this node
+            nodeMaxEnd = delta + node.maxEnd;
+            if (nodeMaxEnd < intervalStart) {
+                // cover case b) from above
+                // there is no need to search this node or its children
+                setNodeIsVisited(node, true);
+                continue;
+            }
+            if (node.left !== SENTINEL) {
+                // go left
+                node = node.left;
+                continue;
+            }
+        }
+        // handle current node
+        nodeStart = delta + node.start;
+        if (nodeStart > intervalEnd) {
+            // cover case a) from above
+            // there is no need to search this node or its right subtree
+            setNodeIsVisited(node, true);
+            continue;
+        }
+        nodeEnd = delta + node.end;
+        if (nodeEnd >= intervalStart) {
+            // There is overlap
+            node.setCachedOffsets(nodeStart, nodeEnd, cachedVersionId);
+            let include = true;
+            if (filterOwnerId && node.ownerId && node.ownerId !== filterOwnerId) {
+                include = false;
+            }
+            if (filterOutValidation && getNodeIsForValidation(node)) {
+                include = false;
+            }
+            if (onlyMarginDecorations && !getNodeIsInGlyphMargin(node)) {
+                include = false;
+            }
+            if (include) {
+                result[resultLen++] = node;
+            }
+        }
+        setNodeIsVisited(node, true);
+        if (node.right !== SENTINEL && !getNodeIsVisited(node.right)) {
+            // go right
+            delta += node.delta;
+            node = node.right;
+            continue;
+        }
+    }
+    setNodeIsVisited(T.root, false);
+    return result;
+}
+//#endregion
+//#region Insertion
+function rbTreeInsert(T, newNode) {
+    if (T.root === SENTINEL) {
+        newNode.parent = SENTINEL;
+        newNode.left = SENTINEL;
+        newNode.right = SENTINEL;
+        setNodeColor(newNode, 0 /* NodeColor.Black */);
+        T.root = newNode;
+        return T.root;
+    }
+    treeInsert(T, newNode);
+    recomputeMaxEndWalkToRoot(newNode.parent);
+    // repair tree
+    let x = newNode;
+    while (x !== T.root && getNodeColor(x.parent) === 1 /* NodeColor.Red */) {
+        if (x.parent === x.parent.parent.left) {
+            const y = x.parent.parent.right;
+            if (getNodeColor(y) === 1 /* NodeColor.Red */) {
+                setNodeColor(x.parent, 0 /* NodeColor.Black */);
+                setNodeColor(y, 0 /* NodeColor.Black */);
+                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
+                x = x.parent.parent;
+            }
+            else {
+                if (x === x.parent.right) {
+                    x = x.parent;
+                    leftRotate(T, x);
+                }
+                setNodeColor(x.parent, 0 /* NodeColor.Black */);
+                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
+                rightRotate(T, x.parent.parent);
+            }
+        }
+        else {
+            const y = x.parent.parent.left;
+            if (getNodeColor(y) === 1 /* NodeColor.Red */) {
+                setNodeColor(x.parent, 0 /* NodeColor.Black */);
+                setNodeColor(y, 0 /* NodeColor.Black */);
+                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
+                x = x.parent.parent;
+            }
+            else {
+                if (x === x.parent.left) {
+                    x = x.parent;
+                    rightRotate(T, x);
+                }
+                setNodeColor(x.parent, 0 /* NodeColor.Black */);
+                setNodeColor(x.parent.parent, 1 /* NodeColor.Red */);
+                leftRotate(T, x.parent.parent);
+            }
+        }
+    }
+    setNodeColor(T.root, 0 /* NodeColor.Black */);
+    return newNode;
+}
+function treeInsert(T, z) {
+    let delta = 0;
+    let x = T.root;
+    const zAbsoluteStart = z.start;
+    const zAbsoluteEnd = z.end;
+    while (true) {
+        const cmp = intervalCompare(zAbsoluteStart, zAbsoluteEnd, x.start + delta, x.end + delta);
+        if (cmp < 0) {
+            // this node should be inserted to the left
+            // => it is not affected by the node's delta
+            if (x.left === SENTINEL) {
+                z.start -= delta;
+                z.end -= delta;
+                z.maxEnd -= delta;
+                x.left = z;
+                break;
+            }
+            else {
+                x = x.left;
+            }
+        }
+        else {
+            // this node should be inserted to the right
+            // => it is not affected by the node's delta
+            if (x.right === SENTINEL) {
+                z.start -= (delta + x.delta);
+                z.end -= (delta + x.delta);
+                z.maxEnd -= (delta + x.delta);
+                x.right = z;
+                break;
+            }
+            else {
+                delta += x.delta;
+                x = x.right;
+            }
+        }
+    }
+    z.parent = x;
+    z.left = SENTINEL;
+    z.right = SENTINEL;
+    setNodeColor(z, 1 /* NodeColor.Red */);
+}
+//#endregion
+//#region Deletion
+function rbTreeDelete(T, z) {
+    let x;
+    let y;
+    // RB-DELETE except we don't swap z and y in case c)
+    // i.e. we always delete what's pointed at by z.
+    if (z.left === SENTINEL) {
+        x = z.right;
+        y = z;
+        // x's delta is no longer influenced by z's delta
+        x.delta += z.delta;
+        if (x.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || x.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
+            T.requestNormalizeDelta = true;
+        }
+        x.start += z.delta;
+        x.end += z.delta;
+    }
+    else if (z.right === SENTINEL) {
+        x = z.left;
+        y = z;
+    }
+    else {
+        y = leftest(z.right);
+        x = y.right;
+        // y's delta is no longer influenced by z's delta,
+        // but we don't want to walk the entire right-hand-side subtree of x.
+        // we therefore maintain z's delta in y, and adjust only x
+        x.start += y.delta;
+        x.end += y.delta;
+        x.delta += y.delta;
+        if (x.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || x.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
+            T.requestNormalizeDelta = true;
+        }
+        y.start += z.delta;
+        y.end += z.delta;
+        y.delta = z.delta;
+        if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
+            T.requestNormalizeDelta = true;
+        }
+    }
+    if (y === T.root) {
+        T.root = x;
+        setNodeColor(x, 0 /* NodeColor.Black */);
+        z.detach();
+        resetSentinel();
+        recomputeMaxEnd(x);
+        T.root.parent = SENTINEL;
+        return;
+    }
+    const yWasRed = (getNodeColor(y) === 1 /* NodeColor.Red */);
+    if (y === y.parent.left) {
+        y.parent.left = x;
+    }
+    else {
+        y.parent.right = x;
+    }
+    if (y === z) {
+        x.parent = y.parent;
+    }
+    else {
+        if (y.parent === z) {
+            x.parent = y;
+        }
+        else {
+            x.parent = y.parent;
+        }
+        y.left = z.left;
+        y.right = z.right;
+        y.parent = z.parent;
+        setNodeColor(y, getNodeColor(z));
+        if (z === T.root) {
+            T.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;
+        }
+    }
+    z.detach();
+    if (yWasRed) {
+        recomputeMaxEndWalkToRoot(x.parent);
+        if (y !== z) {
+            recomputeMaxEndWalkToRoot(y);
+            recomputeMaxEndWalkToRoot(y.parent);
+        }
+        resetSentinel();
+        return;
+    }
+    recomputeMaxEndWalkToRoot(x);
+    recomputeMaxEndWalkToRoot(x.parent);
+    if (y !== z) {
+        recomputeMaxEndWalkToRoot(y);
+        recomputeMaxEndWalkToRoot(y.parent);
+    }
+    // RB-DELETE-FIXUP
+    let w;
+    while (x !== T.root && getNodeColor(x) === 0 /* NodeColor.Black */) {
+        if (x === x.parent.left) {
+            w = x.parent.right;
+            if (getNodeColor(w) === 1 /* NodeColor.Red */) {
+                setNodeColor(w, 0 /* NodeColor.Black */);
+                setNodeColor(x.parent, 1 /* NodeColor.Red */);
+                leftRotate(T, x.parent);
+                w = x.parent.right;
+            }
+            if (getNodeColor(w.left) === 0 /* NodeColor.Black */ && getNodeColor(w.right) === 0 /* NodeColor.Black */) {
+                setNodeColor(w, 1 /* NodeColor.Red */);
+                x = x.parent;
+            }
+            else {
+                if (getNodeColor(w.right) === 0 /* NodeColor.Black */) {
+                    setNodeColor(w.left, 0 /* NodeColor.Black */);
+                    setNodeColor(w, 1 /* NodeColor.Red */);
+                    rightRotate(T, w);
+                    w = x.parent.right;
+                }
+                setNodeColor(w, getNodeColor(x.parent));
+                setNodeColor(x.parent, 0 /* NodeColor.Black */);
+                setNodeColor(w.right, 0 /* NodeColor.Black */);
+                leftRotate(T, x.parent);
+                x = T.root;
+            }
+        }
+        else {
+            w = x.parent.left;
+            if (getNodeColor(w) === 1 /* NodeColor.Red */) {
+                setNodeColor(w, 0 /* NodeColor.Black */);
+                setNodeColor(x.parent, 1 /* NodeColor.Red */);
+                rightRotate(T, x.parent);
+                w = x.parent.left;
+            }
+            if (getNodeColor(w.left) === 0 /* NodeColor.Black */ && getNodeColor(w.right) === 0 /* NodeColor.Black */) {
+                setNodeColor(w, 1 /* NodeColor.Red */);
+                x = x.parent;
+            }
+            else {
+                if (getNodeColor(w.left) === 0 /* NodeColor.Black */) {
+                    setNodeColor(w.right, 0 /* NodeColor.Black */);
+                    setNodeColor(w, 1 /* NodeColor.Red */);
+                    leftRotate(T, w);
+                    w = x.parent.left;
+                }
+                setNodeColor(w, getNodeColor(x.parent));
+                setNodeColor(x.parent, 0 /* NodeColor.Black */);
+                setNodeColor(w.left, 0 /* NodeColor.Black */);
+                rightRotate(T, x.parent);
+                x = T.root;
+            }
+        }
+    }
+    setNodeColor(x, 0 /* NodeColor.Black */);
+    resetSentinel();
+}
+function leftest(node) {
+    while (node.left !== SENTINEL) {
+        node = node.left;
+    }
+    return node;
+}
+function resetSentinel() {
+    SENTINEL.parent = SENTINEL;
+    SENTINEL.delta = 0; // optional
+    SENTINEL.start = 0; // optional
+    SENTINEL.end = 0; // optional
+}
+//#endregion
+//#region Rotations
+function leftRotate(T, x) {
+    const y = x.right; // set y.
+    y.delta += x.delta; // y's delta is no longer influenced by x's delta
+    if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
+        T.requestNormalizeDelta = true;
+    }
+    y.start += x.delta;
+    y.end += x.delta;
+    x.right = y.left; // turn y's left subtree into x's right subtree.
+    if (y.left !== SENTINEL) {
+        y.left.parent = x;
+    }
+    y.parent = x.parent; // link x's parent to y.
+    if (x.parent === SENTINEL) {
+        T.root = y;
+    }
+    else if (x === x.parent.left) {
+        x.parent.left = y;
+    }
+    else {
+        x.parent.right = y;
+    }
+    y.left = x; // put x on y's left.
+    x.parent = y;
+    recomputeMaxEnd(x);
+    recomputeMaxEnd(y);
+}
+function rightRotate(T, y) {
+    const x = y.left;
+    y.delta -= x.delta;
+    if (y.delta < -1073741824 /* Constants.MIN_SAFE_DELTA */ || y.delta > 1073741824 /* Constants.MAX_SAFE_DELTA */) {
+        T.requestNormalizeDelta = true;
+    }
+    y.start -= x.delta;
+    y.end -= x.delta;
+    y.left = x.right;
+    if (x.right !== SENTINEL) {
+        x.right.parent = y;
+    }
+    x.parent = y.parent;
+    if (y.parent === SENTINEL) {
+        T.root = x;
+    }
+    else if (y === y.parent.right) {
+        y.parent.right = x;
+    }
+    else {
+        y.parent.left = x;
+    }
+    x.right = y;
+    y.parent = x;
+    recomputeMaxEnd(y);
+    recomputeMaxEnd(x);
+}
+//#endregion
+//#region max end computation
+function computeMaxEnd(node) {
+    let maxEnd = node.end;
+    if (node.left !== SENTINEL) {
+        const leftMaxEnd = node.left.maxEnd;
+        if (leftMaxEnd > maxEnd) {
+            maxEnd = leftMaxEnd;
+        }
+    }
+    if (node.right !== SENTINEL) {
+        const rightMaxEnd = node.right.maxEnd + node.delta;
+        if (rightMaxEnd > maxEnd) {
+            maxEnd = rightMaxEnd;
+        }
+    }
+    return maxEnd;
+}
+export function recomputeMaxEnd(node) {
+    node.maxEnd = computeMaxEnd(node);
+}
+function recomputeMaxEndWalkToRoot(node) {
+    while (node !== SENTINEL) {
+        const maxEnd = computeMaxEnd(node);
+        if (node.maxEnd === maxEnd) {
+            // no need to go further
+            return;
+        }
+        node.maxEnd = maxEnd;
+        node = node.parent;
+    }
+}
+//#endregion
+//#region utils
+export function intervalCompare(aStart, aEnd, bStart, bEnd) {
+    if (aStart === bStart) {
+        return aEnd - bEnd;
+    }
+    return aStart - bStart;
+}
+//#endregion

node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { splitLines } from '../../../base/common/strings.js';
+import { Position } from '../core/position.js';
+import { PrefixSumComputer } from './prefixSumComputer.js';
+export class MirrorTextModel {
+    constructor(uri, lines, eol, versionId) {
+        this._uri = uri;
+        this._lines = lines;
+        this._eol = eol;
+        this._versionId = versionId;
+        this._lineStarts = null;
+        this._cachedTextValue = null;
+    }
+    dispose() {
+        this._lines.length = 0;
+    }
+    get version() {
+        return this._versionId;
+    }
+    getText() {
+        if (this._cachedTextValue === null) {
+            this._cachedTextValue = this._lines.join(this._eol);
+        }
+        return this._cachedTextValue;
+    }
+    onEvents(e) {
+        if (e.eol && e.eol !== this._eol) {
+            this._eol = e.eol;
+            this._lineStarts = null;
+        }
+        // Update my lines
+        const changes = e.changes;
+        for (const change of changes) {
+            this._acceptDeleteRange(change.range);
+            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);
+        }
+        this._versionId = e.versionId;
+        this._cachedTextValue = null;
+    }
+    _ensureLineStarts() {
+        if (!this._lineStarts) {
+            const eolLength = this._eol.length;
+            const linesLength = this._lines.length;
+            const lineStartValues = new Uint32Array(linesLength);
+            for (let i = 0; i < linesLength; i++) {
+                lineStartValues[i] = this._lines[i].length + eolLength;
+            }
+            this._lineStarts = new PrefixSumComputer(lineStartValues);
+        }
+    }
+    /**
+     * All changes to a line's text go through this method
+     */
+    _setLineText(lineIndex, newValue) {
+        this._lines[lineIndex] = newValue;
+        if (this._lineStarts) {
+            // update prefix sum
+            this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length);
+        }
+    }
+    _acceptDeleteRange(range) {
+        if (range.startLineNumber === range.endLineNumber) {
+            if (range.startColumn === range.endColumn) {
+                // Nothing to delete
+                return;
+            }
+            // Delete text on the affected line
+            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)
+                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));
+            return;
+        }
+        // Take remaining text on last line and append it to remaining text on first line
+        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)
+            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));
+        // Delete middle lines
+        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);
+        if (this._lineStarts) {
+            // update prefix sum
+            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);
+        }
+    }
+    _acceptInsertText(position, insertText) {
+        if (insertText.length === 0) {
+            // Nothing to insert
+            return;
+        }
+        const insertLines = splitLines(insertText);
+        if (insertLines.length === 1) {
+            // Inserting text on one line
+            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)
+                + insertLines[0]
+                + this._lines[position.lineNumber - 1].substring(position.column - 1));
+            return;
+        }
+        // Append overflowing text from first line to the end of text to insert
+        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);
+        // Delete overflowing text from first line and insert text on first line
+        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)
+            + insertLines[0]);
+        // Insert new lines & store lengths
+        const newLengths = new Uint32Array(insertLines.length - 1);
+        for (let i = 1; i < insertLines.length; i++) {
+            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);
+            newLengths[i - 1] = insertLines[i].length + this._eol.length;
+        }
+        if (this._lineStarts) {
+            // update prefix sum
+            this._lineStarts.insertValues(position.lineNumber, newLengths);
+        }
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeBase.js

@@ -0,0 +1,1452 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Position } from '../../core/position.js';
+import { Range } from '../../core/range.js';
+import { FindMatch } from '../../model.js';
+import { SENTINEL, TreeNode, fixInsert, leftest, rbDelete, righttest, updateTreeMetadata } from './rbTreeBase.js';
+import { Searcher, createFindMatch, isValidMatch } from '../textModelSearch.js';
+// const lfRegex = new RegExp(/\r\n|\r|\n/g);
+const AverageBufferSize = 65535;
+function createUintArray(arr) {
+    let r;
+    if (arr[arr.length - 1] < 65536) {
+        r = new Uint16Array(arr.length);
+    }
+    else {
+        r = new Uint32Array(arr.length);
+    }
+    r.set(arr, 0);
+    return r;
+}
+class LineStarts {
+    constructor(lineStarts, cr, lf, crlf, isBasicASCII) {
+        this.lineStarts = lineStarts;
+        this.cr = cr;
+        this.lf = lf;
+        this.crlf = crlf;
+        this.isBasicASCII = isBasicASCII;
+    }
+}
+export function createLineStartsFast(str, readonly = true) {
+    const r = [0];
+    let rLength = 1;
+    for (let i = 0, len = str.length; i < len; i++) {
+        const chr = str.charCodeAt(i);
+        if (chr === 13 /* CharCode.CarriageReturn */) {
+            if (i + 1 < len && str.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
+                // \r\n... case
+                r[rLength++] = i + 2;
+                i++; // skip \n
+            }
+            else {
+                // \r... case
+                r[rLength++] = i + 1;
+            }
+        }
+        else if (chr === 10 /* CharCode.LineFeed */) {
+            r[rLength++] = i + 1;
+        }
+    }
+    if (readonly) {
+        return createUintArray(r);
+    }
+    else {
+        return r;
+    }
+}
+export function createLineStarts(r, str) {
+    r.length = 0;
+    r[0] = 0;
+    let rLength = 1;
+    let cr = 0, lf = 0, crlf = 0;
+    let isBasicASCII = true;
+    for (let i = 0, len = str.length; i < len; i++) {
+        const chr = str.charCodeAt(i);
+        if (chr === 13 /* CharCode.CarriageReturn */) {
+            if (i + 1 < len && str.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
+                // \r\n... case
+                crlf++;
+                r[rLength++] = i + 2;
+                i++; // skip \n
+            }
+            else {
+                cr++;
+                // \r... case
+                r[rLength++] = i + 1;
+            }
+        }
+        else if (chr === 10 /* CharCode.LineFeed */) {
+            lf++;
+            r[rLength++] = i + 1;
+        }
+        else {
+            if (isBasicASCII) {
+                if (chr !== 9 /* CharCode.Tab */ && (chr < 32 || chr > 126)) {
+                    isBasicASCII = false;
+                }
+            }
+        }
+    }
+    const result = new LineStarts(createUintArray(r), cr, lf, crlf, isBasicASCII);
+    r.length = 0;
+    return result;
+}
+export class Piece {
+    constructor(bufferIndex, start, end, lineFeedCnt, length) {
+        this.bufferIndex = bufferIndex;
+        this.start = start;
+        this.end = end;
+        this.lineFeedCnt = lineFeedCnt;
+        this.length = length;
+    }
+}
+export class StringBuffer {
+    constructor(buffer, lineStarts) {
+        this.buffer = buffer;
+        this.lineStarts = lineStarts;
+    }
+}
+/**
+ * Readonly snapshot for piece tree.
+ * In a real multiple thread environment, to make snapshot reading always work correctly, we need to
+ * 1. Make TreeNode.piece immutable, then reading and writing can run in parallel.
+ * 2. TreeNode/Buffers normalization should not happen during snapshot reading.
+ */
+class PieceTreeSnapshot {
+    constructor(tree, BOM) {
+        this._pieces = [];
+        this._tree = tree;
+        this._BOM = BOM;
+        this._index = 0;
+        if (tree.root !== SENTINEL) {
+            tree.iterate(tree.root, node => {
+                if (node !== SENTINEL) {
+                    this._pieces.push(node.piece);
+                }
+                return true;
+            });
+        }
+    }
+    read() {
+        if (this._pieces.length === 0) {
+            if (this._index === 0) {
+                this._index++;
+                return this._BOM;
+            }
+            else {
+                return null;
+            }
+        }
+        if (this._index > this._pieces.length - 1) {
+            return null;
+        }
+        if (this._index === 0) {
+            return this._BOM + this._tree.getPieceContent(this._pieces[this._index++]);
+        }
+        return this._tree.getPieceContent(this._pieces[this._index++]);
+    }
+}
+class PieceTreeSearchCache {
+    constructor(limit) {
+        this._limit = limit;
+        this._cache = [];
+    }
+    get(offset) {
+        for (let i = this._cache.length - 1; i >= 0; i--) {
+            const nodePos = this._cache[i];
+            if (nodePos.nodeStartOffset <= offset && nodePos.nodeStartOffset + nodePos.node.piece.length >= offset) {
+                return nodePos;
+            }
+        }
+        return null;
+    }
+    get2(lineNumber) {
+        for (let i = this._cache.length - 1; i >= 0; i--) {
+            const nodePos = this._cache[i];
+            if (nodePos.nodeStartLineNumber && nodePos.nodeStartLineNumber < lineNumber && nodePos.nodeStartLineNumber + nodePos.node.piece.lineFeedCnt >= lineNumber) {
+                return nodePos;
+            }
+        }
+        return null;
+    }
+    set(nodePosition) {
+        if (this._cache.length >= this._limit) {
+            this._cache.shift();
+        }
+        this._cache.push(nodePosition);
+    }
+    validate(offset) {
+        let hasInvalidVal = false;
+        const tmp = this._cache;
+        for (let i = 0; i < tmp.length; i++) {
+            const nodePos = tmp[i];
+            if (nodePos.node.parent === null || nodePos.nodeStartOffset >= offset) {
+                tmp[i] = null;
+                hasInvalidVal = true;
+                continue;
+            }
+        }
+        if (hasInvalidVal) {
+            const newArr = [];
+            for (const entry of tmp) {
+                if (entry !== null) {
+                    newArr.push(entry);
+                }
+            }
+            this._cache = newArr;
+        }
+    }
+}
+export class PieceTreeBase {
+    constructor(chunks, eol, eolNormalized) {
+        this.create(chunks, eol, eolNormalized);
+    }
+    create(chunks, eol, eolNormalized) {
+        this._buffers = [
+            new StringBuffer('', [0])
+        ];
+        this._lastChangeBufferPos = { line: 0, column: 0 };
+        this.root = SENTINEL;
+        this._lineCnt = 1;
+        this._length = 0;
+        this._EOL = eol;
+        this._EOLLength = eol.length;
+        this._EOLNormalized = eolNormalized;
+        let lastNode = null;
+        for (let i = 0, len = chunks.length; i < len; i++) {
+            if (chunks[i].buffer.length > 0) {
+                if (!chunks[i].lineStarts) {
+                    chunks[i].lineStarts = createLineStartsFast(chunks[i].buffer);
+                }
+                const piece = new Piece(i + 1, { line: 0, column: 0 }, { line: chunks[i].lineStarts.length - 1, column: chunks[i].buffer.length - chunks[i].lineStarts[chunks[i].lineStarts.length - 1] }, chunks[i].lineStarts.length - 1, chunks[i].buffer.length);
+                this._buffers.push(chunks[i]);
+                lastNode = this.rbInsertRight(lastNode, piece);
+            }
+        }
+        this._searchCache = new PieceTreeSearchCache(1);
+        this._lastVisitedLine = { lineNumber: 0, value: '' };
+        this.computeBufferMetadata();
+    }
+    normalizeEOL(eol) {
+        const averageBufferSize = AverageBufferSize;
+        const min = averageBufferSize - Math.floor(averageBufferSize / 3);
+        const max = min * 2;
+        let tempChunk = '';
+        let tempChunkLen = 0;
+        const chunks = [];
+        this.iterate(this.root, node => {
+            const str = this.getNodeContent(node);
+            const len = str.length;
+            if (tempChunkLen <= min || tempChunkLen + len < max) {
+                tempChunk += str;
+                tempChunkLen += len;
+                return true;
+            }
+            // flush anyways
+            const text = tempChunk.replace(/\r\n|\r|\n/g, eol);
+            chunks.push(new StringBuffer(text, createLineStartsFast(text)));
+            tempChunk = str;
+            tempChunkLen = len;
+            return true;
+        });
+        if (tempChunkLen > 0) {
+            const text = tempChunk.replace(/\r\n|\r|\n/g, eol);
+            chunks.push(new StringBuffer(text, createLineStartsFast(text)));
+        }
+        this.create(chunks, eol, true);
+    }
+    // #region Buffer API
+    getEOL() {
+        return this._EOL;
+    }
+    setEOL(newEOL) {
+        this._EOL = newEOL;
+        this._EOLLength = this._EOL.length;
+        this.normalizeEOL(newEOL);
+    }
+    createSnapshot(BOM) {
+        return new PieceTreeSnapshot(this, BOM);
+    }
+    getOffsetAt(lineNumber, column) {
+        let leftLen = 0; // inorder
+        let x = this.root;
+        while (x !== SENTINEL) {
+            if (x.left !== SENTINEL && x.lf_left + 1 >= lineNumber) {
+                x = x.left;
+            }
+            else if (x.lf_left + x.piece.lineFeedCnt + 1 >= lineNumber) {
+                leftLen += x.size_left;
+                // lineNumber >= 2
+                const accumualtedValInCurrentIndex = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                return leftLen += accumualtedValInCurrentIndex + column - 1;
+            }
+            else {
+                lineNumber -= x.lf_left + x.piece.lineFeedCnt;
+                leftLen += x.size_left + x.piece.length;
+                x = x.right;
+            }
+        }
+        return leftLen;
+    }
+    getPositionAt(offset) {
+        offset = Math.floor(offset);
+        offset = Math.max(0, offset);
+        let x = this.root;
+        let lfCnt = 0;
+        const originalOffset = offset;
+        while (x !== SENTINEL) {
+            if (x.size_left !== 0 && x.size_left >= offset) {
+                x = x.left;
+            }
+            else if (x.size_left + x.piece.length >= offset) {
+                const out = this.getIndexOf(x, offset - x.size_left);
+                lfCnt += x.lf_left + out.index;
+                if (out.index === 0) {
+                    const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);
+                    const column = originalOffset - lineStartOffset;
+                    return new Position(lfCnt + 1, column + 1);
+                }
+                return new Position(lfCnt + 1, out.remainder + 1);
+            }
+            else {
+                offset -= x.size_left + x.piece.length;
+                lfCnt += x.lf_left + x.piece.lineFeedCnt;
+                if (x.right === SENTINEL) {
+                    // last node
+                    const lineStartOffset = this.getOffsetAt(lfCnt + 1, 1);
+                    const column = originalOffset - offset - lineStartOffset;
+                    return new Position(lfCnt + 1, column + 1);
+                }
+                else {
+                    x = x.right;
+                }
+            }
+        }
+        return new Position(1, 1);
+    }
+    getValueInRange(range, eol) {
+        if (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn) {
+            return '';
+        }
+        const startPosition = this.nodeAt2(range.startLineNumber, range.startColumn);
+        const endPosition = this.nodeAt2(range.endLineNumber, range.endColumn);
+        const value = this.getValueInRange2(startPosition, endPosition);
+        if (eol) {
+            if (eol !== this._EOL || !this._EOLNormalized) {
+                return value.replace(/\r\n|\r|\n/g, eol);
+            }
+            if (eol === this.getEOL() && this._EOLNormalized) {
+                if (eol === '\r\n') {
+                }
+                return value;
+            }
+            return value.replace(/\r\n|\r|\n/g, eol);
+        }
+        return value;
+    }
+    getValueInRange2(startPosition, endPosition) {
+        if (startPosition.node === endPosition.node) {
+            const node = startPosition.node;
+            const buffer = this._buffers[node.piece.bufferIndex].buffer;
+            const startOffset = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start);
+            return buffer.substring(startOffset + startPosition.remainder, startOffset + endPosition.remainder);
+        }
+        let x = startPosition.node;
+        const buffer = this._buffers[x.piece.bufferIndex].buffer;
+        const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+        let ret = buffer.substring(startOffset + startPosition.remainder, startOffset + x.piece.length);
+        x = x.next();
+        while (x !== SENTINEL) {
+            const buffer = this._buffers[x.piece.bufferIndex].buffer;
+            const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+            if (x === endPosition.node) {
+                ret += buffer.substring(startOffset, startOffset + endPosition.remainder);
+                break;
+            }
+            else {
+                ret += buffer.substr(startOffset, x.piece.length);
+            }
+            x = x.next();
+        }
+        return ret;
+    }
+    getLinesContent() {
+        const lines = [];
+        let linesLength = 0;
+        let currentLine = '';
+        let danglingCR = false;
+        this.iterate(this.root, node => {
+            if (node === SENTINEL) {
+                return true;
+            }
+            const piece = node.piece;
+            let pieceLength = piece.length;
+            if (pieceLength === 0) {
+                return true;
+            }
+            const buffer = this._buffers[piece.bufferIndex].buffer;
+            const lineStarts = this._buffers[piece.bufferIndex].lineStarts;
+            const pieceStartLine = piece.start.line;
+            const pieceEndLine = piece.end.line;
+            let pieceStartOffset = lineStarts[pieceStartLine] + piece.start.column;
+            if (danglingCR) {
+                if (buffer.charCodeAt(pieceStartOffset) === 10 /* CharCode.LineFeed */) {
+                    // pretend the \n was in the previous piece..
+                    pieceStartOffset++;
+                    pieceLength--;
+                }
+                lines[linesLength++] = currentLine;
+                currentLine = '';
+                danglingCR = false;
+                if (pieceLength === 0) {
+                    return true;
+                }
+            }
+            if (pieceStartLine === pieceEndLine) {
+                // this piece has no new lines
+                if (!this._EOLNormalized && buffer.charCodeAt(pieceStartOffset + pieceLength - 1) === 13 /* CharCode.CarriageReturn */) {
+                    danglingCR = true;
+                    currentLine += buffer.substr(pieceStartOffset, pieceLength - 1);
+                }
+                else {
+                    currentLine += buffer.substr(pieceStartOffset, pieceLength);
+                }
+                return true;
+            }
+            // add the text before the first line start in this piece
+            currentLine += (this._EOLNormalized
+                ? buffer.substring(pieceStartOffset, Math.max(pieceStartOffset, lineStarts[pieceStartLine + 1] - this._EOLLength))
+                : buffer.substring(pieceStartOffset, lineStarts[pieceStartLine + 1]).replace(/(\r\n|\r|\n)$/, ''));
+            lines[linesLength++] = currentLine;
+            for (let line = pieceStartLine + 1; line < pieceEndLine; line++) {
+                currentLine = (this._EOLNormalized
+                    ? buffer.substring(lineStarts[line], lineStarts[line + 1] - this._EOLLength)
+                    : buffer.substring(lineStarts[line], lineStarts[line + 1]).replace(/(\r\n|\r|\n)$/, ''));
+                lines[linesLength++] = currentLine;
+            }
+            if (!this._EOLNormalized && buffer.charCodeAt(lineStarts[pieceEndLine] + piece.end.column - 1) === 13 /* CharCode.CarriageReturn */) {
+                danglingCR = true;
+                if (piece.end.column === 0) {
+                    // The last line ended with a \r, let's undo the push, it will be pushed by next iteration
+                    linesLength--;
+                }
+                else {
+                    currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column - 1);
+                }
+            }
+            else {
+                currentLine = buffer.substr(lineStarts[pieceEndLine], piece.end.column);
+            }
+            return true;
+        });
+        if (danglingCR) {
+            lines[linesLength++] = currentLine;
+            currentLine = '';
+        }
+        lines[linesLength++] = currentLine;
+        return lines;
+    }
+    getLength() {
+        return this._length;
+    }
+    getLineCount() {
+        return this._lineCnt;
+    }
+    getLineContent(lineNumber) {
+        if (this._lastVisitedLine.lineNumber === lineNumber) {
+            return this._lastVisitedLine.value;
+        }
+        this._lastVisitedLine.lineNumber = lineNumber;
+        if (lineNumber === this._lineCnt) {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber);
+        }
+        else if (this._EOLNormalized) {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber, this._EOLLength);
+        }
+        else {
+            this._lastVisitedLine.value = this.getLineRawContent(lineNumber).replace(/(\r\n|\r|\n)$/, '');
+        }
+        return this._lastVisitedLine.value;
+    }
+    _getCharCode(nodePos) {
+        if (nodePos.remainder === nodePos.node.piece.length) {
+            // the char we want to fetch is at the head of next node.
+            const matchingNode = nodePos.node.next();
+            if (!matchingNode) {
+                return 0;
+            }
+            const buffer = this._buffers[matchingNode.piece.bufferIndex];
+            const startOffset = this.offsetInBuffer(matchingNode.piece.bufferIndex, matchingNode.piece.start);
+            return buffer.buffer.charCodeAt(startOffset);
+        }
+        else {
+            const buffer = this._buffers[nodePos.node.piece.bufferIndex];
+            const startOffset = this.offsetInBuffer(nodePos.node.piece.bufferIndex, nodePos.node.piece.start);
+            const targetOffset = startOffset + nodePos.remainder;
+            return buffer.buffer.charCodeAt(targetOffset);
+        }
+    }
+    getLineCharCode(lineNumber, index) {
+        const nodePos = this.nodeAt2(lineNumber, index + 1);
+        return this._getCharCode(nodePos);
+    }
+    getLineLength(lineNumber) {
+        if (lineNumber === this.getLineCount()) {
+            const startOffset = this.getOffsetAt(lineNumber, 1);
+            return this.getLength() - startOffset;
+        }
+        return this.getOffsetAt(lineNumber + 1, 1) - this.getOffsetAt(lineNumber, 1) - this._EOLLength;
+    }
+    findMatchesInNode(node, searcher, startLineNumber, startColumn, startCursor, endCursor, searchData, captureMatches, limitResultCount, resultLen, result) {
+        const buffer = this._buffers[node.piece.bufferIndex];
+        const startOffsetInBuffer = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start);
+        const start = this.offsetInBuffer(node.piece.bufferIndex, startCursor);
+        const end = this.offsetInBuffer(node.piece.bufferIndex, endCursor);
+        let m;
+        // Reset regex to search from the beginning
+        const ret = { line: 0, column: 0 };
+        let searchText;
+        let offsetInBuffer;
+        if (searcher._wordSeparators) {
+            searchText = buffer.buffer.substring(start, end);
+            offsetInBuffer = (offset) => offset + start;
+            searcher.reset(0);
+        }
+        else {
+            searchText = buffer.buffer;
+            offsetInBuffer = (offset) => offset;
+            searcher.reset(start);
+        }
+        do {
+            m = searcher.next(searchText);
+            if (m) {
+                if (offsetInBuffer(m.index) >= end) {
+                    return resultLen;
+                }
+                this.positionInBuffer(node, offsetInBuffer(m.index) - startOffsetInBuffer, ret);
+                const lineFeedCnt = this.getLineFeedCnt(node.piece.bufferIndex, startCursor, ret);
+                const retStartColumn = ret.line === startCursor.line ? ret.column - startCursor.column + startColumn : ret.column + 1;
+                const retEndColumn = retStartColumn + m[0].length;
+                result[resultLen++] = createFindMatch(new Range(startLineNumber + lineFeedCnt, retStartColumn, startLineNumber + lineFeedCnt, retEndColumn), m, captureMatches);
+                if (offsetInBuffer(m.index) + m[0].length >= end) {
+                    return resultLen;
+                }
+                if (resultLen >= limitResultCount) {
+                    return resultLen;
+                }
+            }
+        } while (m);
+        return resultLen;
+    }
+    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {
+        const result = [];
+        let resultLen = 0;
+        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);
+        let startPosition = this.nodeAt2(searchRange.startLineNumber, searchRange.startColumn);
+        if (startPosition === null) {
+            return [];
+        }
+        const endPosition = this.nodeAt2(searchRange.endLineNumber, searchRange.endColumn);
+        if (endPosition === null) {
+            return [];
+        }
+        let start = this.positionInBuffer(startPosition.node, startPosition.remainder);
+        const end = this.positionInBuffer(endPosition.node, endPosition.remainder);
+        if (startPosition.node === endPosition.node) {
+            this.findMatchesInNode(startPosition.node, searcher, searchRange.startLineNumber, searchRange.startColumn, start, end, searchData, captureMatches, limitResultCount, resultLen, result);
+            return result;
+        }
+        let startLineNumber = searchRange.startLineNumber;
+        let currentNode = startPosition.node;
+        while (currentNode !== endPosition.node) {
+            const lineBreakCnt = this.getLineFeedCnt(currentNode.piece.bufferIndex, start, currentNode.piece.end);
+            if (lineBreakCnt >= 1) {
+                // last line break position
+                const lineStarts = this._buffers[currentNode.piece.bufferIndex].lineStarts;
+                const startOffsetInBuffer = this.offsetInBuffer(currentNode.piece.bufferIndex, currentNode.piece.start);
+                const nextLineStartOffset = lineStarts[start.line + lineBreakCnt];
+                const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn : 1;
+                resultLen = this.findMatchesInNode(currentNode, searcher, startLineNumber, startColumn, start, this.positionInBuffer(currentNode, nextLineStartOffset - startOffsetInBuffer), searchData, captureMatches, limitResultCount, resultLen, result);
+                if (resultLen >= limitResultCount) {
+                    return result;
+                }
+                startLineNumber += lineBreakCnt;
+            }
+            const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;
+            // search for the remaining content
+            if (startLineNumber === searchRange.endLineNumber) {
+                const text = this.getLineContent(startLineNumber).substring(startColumn, searchRange.endColumn - 1);
+                resultLen = this._findMatchesInLine(searchData, searcher, text, searchRange.endLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);
+                return result;
+            }
+            resultLen = this._findMatchesInLine(searchData, searcher, this.getLineContent(startLineNumber).substr(startColumn), startLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);
+            if (resultLen >= limitResultCount) {
+                return result;
+            }
+            startLineNumber++;
+            startPosition = this.nodeAt2(startLineNumber, 1);
+            currentNode = startPosition.node;
+            start = this.positionInBuffer(startPosition.node, startPosition.remainder);
+        }
+        if (startLineNumber === searchRange.endLineNumber) {
+            const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn - 1 : 0;
+            const text = this.getLineContent(startLineNumber).substring(startColumn, searchRange.endColumn - 1);
+            resultLen = this._findMatchesInLine(searchData, searcher, text, searchRange.endLineNumber, startColumn, resultLen, result, captureMatches, limitResultCount);
+            return result;
+        }
+        const startColumn = startLineNumber === searchRange.startLineNumber ? searchRange.startColumn : 1;
+        resultLen = this.findMatchesInNode(endPosition.node, searcher, startLineNumber, startColumn, start, end, searchData, captureMatches, limitResultCount, resultLen, result);
+        return result;
+    }
+    _findMatchesInLine(searchData, searcher, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {
+        const wordSeparators = searchData.wordSeparators;
+        if (!captureMatches && searchData.simpleSearch) {
+            const searchString = searchData.simpleSearch;
+            const searchStringLen = searchString.length;
+            const textLength = text.length;
+            let lastMatchIndex = -searchStringLen;
+            while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {
+                if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {
+                    result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);
+                    if (resultLen >= limitResultCount) {
+                        return resultLen;
+                    }
+                }
+            }
+            return resultLen;
+        }
+        let m;
+        // Reset regex to search from the beginning
+        searcher.reset(0);
+        do {
+            m = searcher.next(text);
+            if (m) {
+                result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);
+                if (resultLen >= limitResultCount) {
+                    return resultLen;
+                }
+            }
+        } while (m);
+        return resultLen;
+    }
+    // #endregion
+    // #region Piece Table
+    insert(offset, value, eolNormalized = false) {
+        this._EOLNormalized = this._EOLNormalized && eolNormalized;
+        this._lastVisitedLine.lineNumber = 0;
+        this._lastVisitedLine.value = '';
+        if (this.root !== SENTINEL) {
+            const { node, remainder, nodeStartOffset } = this.nodeAt(offset);
+            const piece = node.piece;
+            const bufferIndex = piece.bufferIndex;
+            const insertPosInBuffer = this.positionInBuffer(node, remainder);
+            if (node.piece.bufferIndex === 0 &&
+                piece.end.line === this._lastChangeBufferPos.line &&
+                piece.end.column === this._lastChangeBufferPos.column &&
+                (nodeStartOffset + piece.length === offset) &&
+                value.length < AverageBufferSize) {
+                // changed buffer
+                this.appendToNode(node, value);
+                this.computeBufferMetadata();
+                return;
+            }
+            if (nodeStartOffset === offset) {
+                this.insertContentToNodeLeft(value, node);
+                this._searchCache.validate(offset);
+            }
+            else if (nodeStartOffset + node.piece.length > offset) {
+                // we are inserting into the middle of a node.
+                const nodesToDel = [];
+                let newRightPiece = new Piece(piece.bufferIndex, insertPosInBuffer, piece.end, this.getLineFeedCnt(piece.bufferIndex, insertPosInBuffer, piece.end), this.offsetInBuffer(bufferIndex, piece.end) - this.offsetInBuffer(bufferIndex, insertPosInBuffer));
+                if (this.shouldCheckCRLF() && this.endWithCR(value)) {
+                    const headOfRight = this.nodeCharCodeAt(node, remainder);
+                    if (headOfRight === 10 /** \n */) {
+                        const newStart = { line: newRightPiece.start.line + 1, column: 0 };
+                        newRightPiece = new Piece(newRightPiece.bufferIndex, newStart, newRightPiece.end, this.getLineFeedCnt(newRightPiece.bufferIndex, newStart, newRightPiece.end), newRightPiece.length - 1);
+                        value += '\n';
+                    }
+                }
+                // reuse node for content before insertion point.
+                if (this.shouldCheckCRLF() && this.startWithLF(value)) {
+                    const tailOfLeft = this.nodeCharCodeAt(node, remainder - 1);
+                    if (tailOfLeft === 13 /** \r */) {
+                        const previousPos = this.positionInBuffer(node, remainder - 1);
+                        this.deleteNodeTail(node, previousPos);
+                        value = '\r' + value;
+                        if (node.piece.length === 0) {
+                            nodesToDel.push(node);
+                        }
+                    }
+                    else {
+                        this.deleteNodeTail(node, insertPosInBuffer);
+                    }
+                }
+                else {
+                    this.deleteNodeTail(node, insertPosInBuffer);
+                }
+                const newPieces = this.createNewPieces(value);
+                if (newRightPiece.length > 0) {
+                    this.rbInsertRight(node, newRightPiece);
+                }
+                let tmpNode = node;
+                for (let k = 0; k < newPieces.length; k++) {
+                    tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);
+                }
+                this.deleteNodes(nodesToDel);
+            }
+            else {
+                this.insertContentToNodeRight(value, node);
+            }
+        }
+        else {
+            // insert new node
+            const pieces = this.createNewPieces(value);
+            let node = this.rbInsertLeft(null, pieces[0]);
+            for (let k = 1; k < pieces.length; k++) {
+                node = this.rbInsertRight(node, pieces[k]);
+            }
+        }
+        // todo, this is too brutal. Total line feed count should be updated the same way as lf_left.
+        this.computeBufferMetadata();
+    }
+    delete(offset, cnt) {
+        this._lastVisitedLine.lineNumber = 0;
+        this._lastVisitedLine.value = '';
+        if (cnt <= 0 || this.root === SENTINEL) {
+            return;
+        }
+        const startPosition = this.nodeAt(offset);
+        const endPosition = this.nodeAt(offset + cnt);
+        const startNode = startPosition.node;
+        const endNode = endPosition.node;
+        if (startNode === endNode) {
+            const startSplitPosInBuffer = this.positionInBuffer(startNode, startPosition.remainder);
+            const endSplitPosInBuffer = this.positionInBuffer(startNode, endPosition.remainder);
+            if (startPosition.nodeStartOffset === offset) {
+                if (cnt === startNode.piece.length) { // delete node
+                    const next = startNode.next();
+                    rbDelete(this, startNode);
+                    this.validateCRLFWithPrevNode(next);
+                    this.computeBufferMetadata();
+                    return;
+                }
+                this.deleteNodeHead(startNode, endSplitPosInBuffer);
+                this._searchCache.validate(offset);
+                this.validateCRLFWithPrevNode(startNode);
+                this.computeBufferMetadata();
+                return;
+            }
+            if (startPosition.nodeStartOffset + startNode.piece.length === offset + cnt) {
+                this.deleteNodeTail(startNode, startSplitPosInBuffer);
+                this.validateCRLFWithNextNode(startNode);
+                this.computeBufferMetadata();
+                return;
+            }
+            // delete content in the middle, this node will be splitted to nodes
+            this.shrinkNode(startNode, startSplitPosInBuffer, endSplitPosInBuffer);
+            this.computeBufferMetadata();
+            return;
+        }
+        const nodesToDel = [];
+        const startSplitPosInBuffer = this.positionInBuffer(startNode, startPosition.remainder);
+        this.deleteNodeTail(startNode, startSplitPosInBuffer);
+        this._searchCache.validate(offset);
+        if (startNode.piece.length === 0) {
+            nodesToDel.push(startNode);
+        }
+        // update last touched node
+        const endSplitPosInBuffer = this.positionInBuffer(endNode, endPosition.remainder);
+        this.deleteNodeHead(endNode, endSplitPosInBuffer);
+        if (endNode.piece.length === 0) {
+            nodesToDel.push(endNode);
+        }
+        // delete nodes in between
+        const secondNode = startNode.next();
+        for (let node = secondNode; node !== SENTINEL && node !== endNode; node = node.next()) {
+            nodesToDel.push(node);
+        }
+        const prev = startNode.piece.length === 0 ? startNode.prev() : startNode;
+        this.deleteNodes(nodesToDel);
+        this.validateCRLFWithNextNode(prev);
+        this.computeBufferMetadata();
+    }
+    insertContentToNodeLeft(value, node) {
+        // we are inserting content to the beginning of node
+        const nodesToDel = [];
+        if (this.shouldCheckCRLF() && this.endWithCR(value) && this.startWithLF(node)) {
+            // move `\n` to new node.
+            const piece = node.piece;
+            const newStart = { line: piece.start.line + 1, column: 0 };
+            const nPiece = new Piece(piece.bufferIndex, newStart, piece.end, this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end), piece.length - 1);
+            node.piece = nPiece;
+            value += '\n';
+            updateTreeMetadata(this, node, -1, -1);
+            if (node.piece.length === 0) {
+                nodesToDel.push(node);
+            }
+        }
+        const newPieces = this.createNewPieces(value);
+        let newNode = this.rbInsertLeft(node, newPieces[newPieces.length - 1]);
+        for (let k = newPieces.length - 2; k >= 0; k--) {
+            newNode = this.rbInsertLeft(newNode, newPieces[k]);
+        }
+        this.validateCRLFWithPrevNode(newNode);
+        this.deleteNodes(nodesToDel);
+    }
+    insertContentToNodeRight(value, node) {
+        // we are inserting to the right of this node.
+        if (this.adjustCarriageReturnFromNext(value, node)) {
+            // move \n to the new node.
+            value += '\n';
+        }
+        const newPieces = this.createNewPieces(value);
+        const newNode = this.rbInsertRight(node, newPieces[0]);
+        let tmpNode = newNode;
+        for (let k = 1; k < newPieces.length; k++) {
+            tmpNode = this.rbInsertRight(tmpNode, newPieces[k]);
+        }
+        this.validateCRLFWithPrevNode(newNode);
+    }
+    positionInBuffer(node, remainder, ret) {
+        const piece = node.piece;
+        const bufferIndex = node.piece.bufferIndex;
+        const lineStarts = this._buffers[bufferIndex].lineStarts;
+        const startOffset = lineStarts[piece.start.line] + piece.start.column;
+        const offset = startOffset + remainder;
+        // binary search offset between startOffset and endOffset
+        let low = piece.start.line;
+        let high = piece.end.line;
+        let mid = 0;
+        let midStop = 0;
+        let midStart = 0;
+        while (low <= high) {
+            mid = low + ((high - low) / 2) | 0;
+            midStart = lineStarts[mid];
+            if (mid === high) {
+                break;
+            }
+            midStop = lineStarts[mid + 1];
+            if (offset < midStart) {
+                high = mid - 1;
+            }
+            else if (offset >= midStop) {
+                low = mid + 1;
+            }
+            else {
+                break;
+            }
+        }
+        if (ret) {
+            ret.line = mid;
+            ret.column = offset - midStart;
+            return null;
+        }
+        return {
+            line: mid,
+            column: offset - midStart
+        };
+    }
+    getLineFeedCnt(bufferIndex, start, end) {
+        // we don't need to worry about start: abc\r|\n, or abc|\r, or abc|\n, or abc|\r\n doesn't change the fact that, there is one line break after start.
+        // now let's take care of end: abc\r|\n, if end is in between \r and \n, we need to add line feed count by 1
+        if (end.column === 0) {
+            return end.line - start.line;
+        }
+        const lineStarts = this._buffers[bufferIndex].lineStarts;
+        if (end.line === lineStarts.length - 1) { // it means, there is no \n after end, otherwise, there will be one more lineStart.
+            return end.line - start.line;
+        }
+        const nextLineStartOffset = lineStarts[end.line + 1];
+        const endOffset = lineStarts[end.line] + end.column;
+        if (nextLineStartOffset > endOffset + 1) { // there are more than 1 character after end, which means it can't be \n
+            return end.line - start.line;
+        }
+        // endOffset + 1 === nextLineStartOffset
+        // character at endOffset is \n, so we check the character before first
+        // if character at endOffset is \r, end.column is 0 and we can't get here.
+        const previousCharOffset = endOffset - 1; // end.column > 0 so it's okay.
+        const buffer = this._buffers[bufferIndex].buffer;
+        if (buffer.charCodeAt(previousCharOffset) === 13) {
+            return end.line - start.line + 1;
+        }
+        else {
+            return end.line - start.line;
+        }
+    }
+    offsetInBuffer(bufferIndex, cursor) {
+        const lineStarts = this._buffers[bufferIndex].lineStarts;
+        return lineStarts[cursor.line] + cursor.column;
+    }
+    deleteNodes(nodes) {
+        for (let i = 0; i < nodes.length; i++) {
+            rbDelete(this, nodes[i]);
+        }
+    }
+    createNewPieces(text) {
+        if (text.length > AverageBufferSize) {
+            // the content is large, operations like substring, charCode becomes slow
+            // so here we split it into smaller chunks, just like what we did for CR/LF normalization
+            const newPieces = [];
+            while (text.length > AverageBufferSize) {
+                const lastChar = text.charCodeAt(AverageBufferSize - 1);
+                let splitText;
+                if (lastChar === 13 /* CharCode.CarriageReturn */ || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
+                    // last character is \r or a high surrogate => keep it back
+                    splitText = text.substring(0, AverageBufferSize - 1);
+                    text = text.substring(AverageBufferSize - 1);
+                }
+                else {
+                    splitText = text.substring(0, AverageBufferSize);
+                    text = text.substring(AverageBufferSize);
+                }
+                const lineStarts = createLineStartsFast(splitText);
+                newPieces.push(new Piece(this._buffers.length, /* buffer index */ { line: 0, column: 0 }, { line: lineStarts.length - 1, column: splitText.length - lineStarts[lineStarts.length - 1] }, lineStarts.length - 1, splitText.length));
+                this._buffers.push(new StringBuffer(splitText, lineStarts));
+            }
+            const lineStarts = createLineStartsFast(text);
+            newPieces.push(new Piece(this._buffers.length, /* buffer index */ { line: 0, column: 0 }, { line: lineStarts.length - 1, column: text.length - lineStarts[lineStarts.length - 1] }, lineStarts.length - 1, text.length));
+            this._buffers.push(new StringBuffer(text, lineStarts));
+            return newPieces;
+        }
+        let startOffset = this._buffers[0].buffer.length;
+        const lineStarts = createLineStartsFast(text, false);
+        let start = this._lastChangeBufferPos;
+        if (this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 1] === startOffset
+            && startOffset !== 0
+            && this.startWithLF(text)
+            && this.endWithCR(this._buffers[0].buffer) // todo, we can check this._lastChangeBufferPos's column as it's the last one
+        ) {
+            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line, column: this._lastChangeBufferPos.column + 1 };
+            start = this._lastChangeBufferPos;
+            for (let i = 0; i < lineStarts.length; i++) {
+                lineStarts[i] += startOffset + 1;
+            }
+            this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));
+            this._buffers[0].buffer += '_' + text;
+            startOffset += 1;
+        }
+        else {
+            if (startOffset !== 0) {
+                for (let i = 0; i < lineStarts.length; i++) {
+                    lineStarts[i] += startOffset;
+                }
+            }
+            this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));
+            this._buffers[0].buffer += text;
+        }
+        const endOffset = this._buffers[0].buffer.length;
+        const endIndex = this._buffers[0].lineStarts.length - 1;
+        const endColumn = endOffset - this._buffers[0].lineStarts[endIndex];
+        const endPos = { line: endIndex, column: endColumn };
+        const newPiece = new Piece(0, /** todo@peng */ start, endPos, this.getLineFeedCnt(0, start, endPos), endOffset - startOffset);
+        this._lastChangeBufferPos = endPos;
+        return [newPiece];
+    }
+    getLineRawContent(lineNumber, endOffset = 0) {
+        let x = this.root;
+        let ret = '';
+        const cache = this._searchCache.get2(lineNumber);
+        if (cache) {
+            x = cache.node;
+            const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber - 1);
+            const buffer = this._buffers[x.piece.bufferIndex].buffer;
+            const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+            if (cache.nodeStartLineNumber + x.piece.lineFeedCnt === lineNumber) {
+                ret = buffer.substring(startOffset + prevAccumulatedValue, startOffset + x.piece.length);
+            }
+            else {
+                const accumulatedValue = this.getAccumulatedValue(x, lineNumber - cache.nodeStartLineNumber);
+                return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);
+            }
+        }
+        else {
+            let nodeStartOffset = 0;
+            const originalLineNumber = lineNumber;
+            while (x !== SENTINEL) {
+                if (x.left !== SENTINEL && x.lf_left >= lineNumber - 1) {
+                    x = x.left;
+                }
+                else if (x.lf_left + x.piece.lineFeedCnt > lineNumber - 1) {
+                    const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                    const accumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 1);
+                    const buffer = this._buffers[x.piece.bufferIndex].buffer;
+                    const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                    nodeStartOffset += x.size_left;
+                    this._searchCache.set({
+                        node: x,
+                        nodeStartOffset,
+                        nodeStartLineNumber: originalLineNumber - (lineNumber - 1 - x.lf_left)
+                    });
+                    return buffer.substring(startOffset + prevAccumulatedValue, startOffset + accumulatedValue - endOffset);
+                }
+                else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {
+                    const prevAccumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                    const buffer = this._buffers[x.piece.bufferIndex].buffer;
+                    const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                    ret = buffer.substring(startOffset + prevAccumulatedValue, startOffset + x.piece.length);
+                    break;
+                }
+                else {
+                    lineNumber -= x.lf_left + x.piece.lineFeedCnt;
+                    nodeStartOffset += x.size_left + x.piece.length;
+                    x = x.right;
+                }
+            }
+        }
+        // search in order, to find the node contains end column
+        x = x.next();
+        while (x !== SENTINEL) {
+            const buffer = this._buffers[x.piece.bufferIndex].buffer;
+            if (x.piece.lineFeedCnt > 0) {
+                const accumulatedValue = this.getAccumulatedValue(x, 0);
+                const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                ret += buffer.substring(startOffset, startOffset + accumulatedValue - endOffset);
+                return ret;
+            }
+            else {
+                const startOffset = this.offsetInBuffer(x.piece.bufferIndex, x.piece.start);
+                ret += buffer.substr(startOffset, x.piece.length);
+            }
+            x = x.next();
+        }
+        return ret;
+    }
+    computeBufferMetadata() {
+        let x = this.root;
+        let lfCnt = 1;
+        let len = 0;
+        while (x !== SENTINEL) {
+            lfCnt += x.lf_left + x.piece.lineFeedCnt;
+            len += x.size_left + x.piece.length;
+            x = x.right;
+        }
+        this._lineCnt = lfCnt;
+        this._length = len;
+        this._searchCache.validate(this._length);
+    }
+    // #region node operations
+    getIndexOf(node, accumulatedValue) {
+        const piece = node.piece;
+        const pos = this.positionInBuffer(node, accumulatedValue);
+        const lineCnt = pos.line - piece.start.line;
+        if (this.offsetInBuffer(piece.bufferIndex, piece.end) - this.offsetInBuffer(piece.bufferIndex, piece.start) === accumulatedValue) {
+            // we are checking the end of this node, so a CRLF check is necessary.
+            const realLineCnt = this.getLineFeedCnt(node.piece.bufferIndex, piece.start, pos);
+            if (realLineCnt !== lineCnt) {
+                // aha yes, CRLF
+                return { index: realLineCnt, remainder: 0 };
+            }
+        }
+        return { index: lineCnt, remainder: pos.column };
+    }
+    getAccumulatedValue(node, index) {
+        if (index < 0) {
+            return 0;
+        }
+        const piece = node.piece;
+        const lineStarts = this._buffers[piece.bufferIndex].lineStarts;
+        const expectedLineStartIndex = piece.start.line + index + 1;
+        if (expectedLineStartIndex > piece.end.line) {
+            return lineStarts[piece.end.line] + piece.end.column - lineStarts[piece.start.line] - piece.start.column;
+        }
+        else {
+            return lineStarts[expectedLineStartIndex] - lineStarts[piece.start.line] - piece.start.column;
+        }
+    }
+    deleteNodeTail(node, pos) {
+        const piece = node.piece;
+        const originalLFCnt = piece.lineFeedCnt;
+        const originalEndOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);
+        const newEnd = pos;
+        const newEndOffset = this.offsetInBuffer(piece.bufferIndex, newEnd);
+        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, piece.start, newEnd);
+        const lf_delta = newLineFeedCnt - originalLFCnt;
+        const size_delta = newEndOffset - originalEndOffset;
+        const newLength = piece.length + size_delta;
+        node.piece = new Piece(piece.bufferIndex, piece.start, newEnd, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, node, size_delta, lf_delta);
+    }
+    deleteNodeHead(node, pos) {
+        const piece = node.piece;
+        const originalLFCnt = piece.lineFeedCnt;
+        const originalStartOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);
+        const newStart = pos;
+        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end);
+        const newStartOffset = this.offsetInBuffer(piece.bufferIndex, newStart);
+        const lf_delta = newLineFeedCnt - originalLFCnt;
+        const size_delta = originalStartOffset - newStartOffset;
+        const newLength = piece.length + size_delta;
+        node.piece = new Piece(piece.bufferIndex, newStart, piece.end, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, node, size_delta, lf_delta);
+    }
+    shrinkNode(node, start, end) {
+        const piece = node.piece;
+        const originalStartPos = piece.start;
+        const originalEndPos = piece.end;
+        // old piece, originalStartPos, start
+        const oldLength = piece.length;
+        const oldLFCnt = piece.lineFeedCnt;
+        const newEnd = start;
+        const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, piece.start, newEnd);
+        const newLength = this.offsetInBuffer(piece.bufferIndex, start) - this.offsetInBuffer(piece.bufferIndex, originalStartPos);
+        node.piece = new Piece(piece.bufferIndex, piece.start, newEnd, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, node, newLength - oldLength, newLineFeedCnt - oldLFCnt);
+        // new right piece, end, originalEndPos
+        const newPiece = new Piece(piece.bufferIndex, end, originalEndPos, this.getLineFeedCnt(piece.bufferIndex, end, originalEndPos), this.offsetInBuffer(piece.bufferIndex, originalEndPos) - this.offsetInBuffer(piece.bufferIndex, end));
+        const newNode = this.rbInsertRight(node, newPiece);
+        this.validateCRLFWithPrevNode(newNode);
+    }
+    appendToNode(node, value) {
+        if (this.adjustCarriageReturnFromNext(value, node)) {
+            value += '\n';
+        }
+        const hitCRLF = this.shouldCheckCRLF() && this.startWithLF(value) && this.endWithCR(node);
+        const startOffset = this._buffers[0].buffer.length;
+        this._buffers[0].buffer += value;
+        const lineStarts = createLineStartsFast(value, false);
+        for (let i = 0; i < lineStarts.length; i++) {
+            lineStarts[i] += startOffset;
+        }
+        if (hitCRLF) {
+            const prevStartOffset = this._buffers[0].lineStarts[this._buffers[0].lineStarts.length - 2];
+            this._buffers[0].lineStarts.pop();
+            // _lastChangeBufferPos is already wrong
+            this._lastChangeBufferPos = { line: this._lastChangeBufferPos.line - 1, column: startOffset - prevStartOffset };
+        }
+        this._buffers[0].lineStarts = this._buffers[0].lineStarts.concat(lineStarts.slice(1));
+        const endIndex = this._buffers[0].lineStarts.length - 1;
+        const endColumn = this._buffers[0].buffer.length - this._buffers[0].lineStarts[endIndex];
+        const newEnd = { line: endIndex, column: endColumn };
+        const newLength = node.piece.length + value.length;
+        const oldLineFeedCnt = node.piece.lineFeedCnt;
+        const newLineFeedCnt = this.getLineFeedCnt(0, node.piece.start, newEnd);
+        const lf_delta = newLineFeedCnt - oldLineFeedCnt;
+        node.piece = new Piece(node.piece.bufferIndex, node.piece.start, newEnd, newLineFeedCnt, newLength);
+        this._lastChangeBufferPos = newEnd;
+        updateTreeMetadata(this, node, value.length, lf_delta);
+    }
+    nodeAt(offset) {
+        let x = this.root;
+        const cache = this._searchCache.get(offset);
+        if (cache) {
+            return {
+                node: cache.node,
+                nodeStartOffset: cache.nodeStartOffset,
+                remainder: offset - cache.nodeStartOffset
+            };
+        }
+        let nodeStartOffset = 0;
+        while (x !== SENTINEL) {
+            if (x.size_left > offset) {
+                x = x.left;
+            }
+            else if (x.size_left + x.piece.length >= offset) {
+                nodeStartOffset += x.size_left;
+                const ret = {
+                    node: x,
+                    remainder: offset - x.size_left,
+                    nodeStartOffset
+                };
+                this._searchCache.set(ret);
+                return ret;
+            }
+            else {
+                offset -= x.size_left + x.piece.length;
+                nodeStartOffset += x.size_left + x.piece.length;
+                x = x.right;
+            }
+        }
+        return null;
+    }
+    nodeAt2(lineNumber, column) {
+        let x = this.root;
+        let nodeStartOffset = 0;
+        while (x !== SENTINEL) {
+            if (x.left !== SENTINEL && x.lf_left >= lineNumber - 1) {
+                x = x.left;
+            }
+            else if (x.lf_left + x.piece.lineFeedCnt > lineNumber - 1) {
+                const prevAccumualtedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                const accumulatedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 1);
+                nodeStartOffset += x.size_left;
+                return {
+                    node: x,
+                    remainder: Math.min(prevAccumualtedValue + column - 1, accumulatedValue),
+                    nodeStartOffset
+                };
+            }
+            else if (x.lf_left + x.piece.lineFeedCnt === lineNumber - 1) {
+                const prevAccumualtedValue = this.getAccumulatedValue(x, lineNumber - x.lf_left - 2);
+                if (prevAccumualtedValue + column - 1 <= x.piece.length) {
+                    return {
+                        node: x,
+                        remainder: prevAccumualtedValue + column - 1,
+                        nodeStartOffset
+                    };
+                }
+                else {
+                    column -= x.piece.length - prevAccumualtedValue;
+                    break;
+                }
+            }
+            else {
+                lineNumber -= x.lf_left + x.piece.lineFeedCnt;
+                nodeStartOffset += x.size_left + x.piece.length;
+                x = x.right;
+            }
+        }
+        // search in order, to find the node contains position.column
+        x = x.next();
+        while (x !== SENTINEL) {
+            if (x.piece.lineFeedCnt > 0) {
+                const accumulatedValue = this.getAccumulatedValue(x, 0);
+                const nodeStartOffset = this.offsetOfNode(x);
+                return {
+                    node: x,
+                    remainder: Math.min(column - 1, accumulatedValue),
+                    nodeStartOffset
+                };
+            }
+            else {
+                if (x.piece.length >= column - 1) {
+                    const nodeStartOffset = this.offsetOfNode(x);
+                    return {
+                        node: x,
+                        remainder: column - 1,
+                        nodeStartOffset
+                    };
+                }
+                else {
+                    column -= x.piece.length;
+                }
+            }
+            x = x.next();
+        }
+        return null;
+    }
+    nodeCharCodeAt(node, offset) {
+        if (node.piece.lineFeedCnt < 1) {
+            return -1;
+        }
+        const buffer = this._buffers[node.piece.bufferIndex];
+        const newOffset = this.offsetInBuffer(node.piece.bufferIndex, node.piece.start) + offset;
+        return buffer.buffer.charCodeAt(newOffset);
+    }
+    offsetOfNode(node) {
+        if (!node) {
+            return 0;
+        }
+        let pos = node.size_left;
+        while (node !== this.root) {
+            if (node.parent.right === node) {
+                pos += node.parent.size_left + node.parent.piece.length;
+            }
+            node = node.parent;
+        }
+        return pos;
+    }
+    // #endregion
+    // #region CRLF
+    shouldCheckCRLF() {
+        return !(this._EOLNormalized && this._EOL === '\n');
+    }
+    startWithLF(val) {
+        if (typeof val === 'string') {
+            return val.charCodeAt(0) === 10;
+        }
+        if (val === SENTINEL || val.piece.lineFeedCnt === 0) {
+            return false;
+        }
+        const piece = val.piece;
+        const lineStarts = this._buffers[piece.bufferIndex].lineStarts;
+        const line = piece.start.line;
+        const startOffset = lineStarts[line] + piece.start.column;
+        if (line === lineStarts.length - 1) {
+            // last line, so there is no line feed at the end of this line
+            return false;
+        }
+        const nextLineOffset = lineStarts[line + 1];
+        if (nextLineOffset > startOffset + 1) {
+            return false;
+        }
+        return this._buffers[piece.bufferIndex].buffer.charCodeAt(startOffset) === 10;
+    }
+    endWithCR(val) {
+        if (typeof val === 'string') {
+            return val.charCodeAt(val.length - 1) === 13;
+        }
+        if (val === SENTINEL || val.piece.lineFeedCnt === 0) {
+            return false;
+        }
+        return this.nodeCharCodeAt(val, val.piece.length - 1) === 13;
+    }
+    validateCRLFWithPrevNode(nextNode) {
+        if (this.shouldCheckCRLF() && this.startWithLF(nextNode)) {
+            const node = nextNode.prev();
+            if (this.endWithCR(node)) {
+                this.fixCRLF(node, nextNode);
+            }
+        }
+    }
+    validateCRLFWithNextNode(node) {
+        if (this.shouldCheckCRLF() && this.endWithCR(node)) {
+            const nextNode = node.next();
+            if (this.startWithLF(nextNode)) {
+                this.fixCRLF(node, nextNode);
+            }
+        }
+    }
+    fixCRLF(prev, next) {
+        const nodesToDel = [];
+        // update node
+        const lineStarts = this._buffers[prev.piece.bufferIndex].lineStarts;
+        let newEnd;
+        if (prev.piece.end.column === 0) {
+            // it means, last line ends with \r, not \r\n
+            newEnd = { line: prev.piece.end.line - 1, column: lineStarts[prev.piece.end.line] - lineStarts[prev.piece.end.line - 1] - 1 };
+        }
+        else {
+            // \r\n
+            newEnd = { line: prev.piece.end.line, column: prev.piece.end.column - 1 };
+        }
+        const prevNewLength = prev.piece.length - 1;
+        const prevNewLFCnt = prev.piece.lineFeedCnt - 1;
+        prev.piece = new Piece(prev.piece.bufferIndex, prev.piece.start, newEnd, prevNewLFCnt, prevNewLength);
+        updateTreeMetadata(this, prev, -1, -1);
+        if (prev.piece.length === 0) {
+            nodesToDel.push(prev);
+        }
+        // update nextNode
+        const newStart = { line: next.piece.start.line + 1, column: 0 };
+        const newLength = next.piece.length - 1;
+        const newLineFeedCnt = this.getLineFeedCnt(next.piece.bufferIndex, newStart, next.piece.end);
+        next.piece = new Piece(next.piece.bufferIndex, newStart, next.piece.end, newLineFeedCnt, newLength);
+        updateTreeMetadata(this, next, -1, -1);
+        if (next.piece.length === 0) {
+            nodesToDel.push(next);
+        }
+        // create new piece which contains \r\n
+        const pieces = this.createNewPieces('\r\n');
+        this.rbInsertRight(prev, pieces[0]);
+        // delete empty nodes
+        for (let i = 0; i < nodesToDel.length; i++) {
+            rbDelete(this, nodesToDel[i]);
+        }
+    }
+    adjustCarriageReturnFromNext(value, node) {
+        if (this.shouldCheckCRLF() && this.endWithCR(value)) {
+            const nextNode = node.next();
+            if (this.startWithLF(nextNode)) {
+                // move `\n` forward
+                value += '\n';
+                if (nextNode.piece.length === 1) {
+                    rbDelete(this, nextNode);
+                }
+                else {
+                    const piece = nextNode.piece;
+                    const newStart = { line: piece.start.line + 1, column: 0 };
+                    const newLength = piece.length - 1;
+                    const newLineFeedCnt = this.getLineFeedCnt(piece.bufferIndex, newStart, piece.end);
+                    nextNode.piece = new Piece(piece.bufferIndex, newStart, piece.end, newLineFeedCnt, newLength);
+                    updateTreeMetadata(this, nextNode, -1, -1);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    // #endregion
+    // #endregion
+    // #region Tree operations
+    iterate(node, callback) {
+        if (node === SENTINEL) {
+            return callback(SENTINEL);
+        }
+        const leftRet = this.iterate(node.left, callback);
+        if (!leftRet) {
+            return leftRet;
+        }
+        return callback(node) && this.iterate(node.right, callback);
+    }
+    getNodeContent(node) {
+        if (node === SENTINEL) {
+            return '';
+        }
+        const buffer = this._buffers[node.piece.bufferIndex];
+        const piece = node.piece;
+        const startOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);
+        const endOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);
+        const currentContent = buffer.buffer.substring(startOffset, endOffset);
+        return currentContent;
+    }
+    getPieceContent(piece) {
+        const buffer = this._buffers[piece.bufferIndex];
+        const startOffset = this.offsetInBuffer(piece.bufferIndex, piece.start);
+        const endOffset = this.offsetInBuffer(piece.bufferIndex, piece.end);
+        const currentContent = buffer.buffer.substring(startOffset, endOffset);
+        return currentContent;
+    }
+    /**
+     *      node              node
+     *     /  \              /  \
+     *    a   b    <----   a    b
+     *                         /
+     *                        z
+     */
+    rbInsertRight(node, p) {
+        const z = new TreeNode(p, 1 /* NodeColor.Red */);
+        z.left = SENTINEL;
+        z.right = SENTINEL;
+        z.parent = SENTINEL;
+        z.size_left = 0;
+        z.lf_left = 0;
+        const x = this.root;
+        if (x === SENTINEL) {
+            this.root = z;
+            z.color = 0 /* NodeColor.Black */;
+        }
+        else if (node.right === SENTINEL) {
+            node.right = z;
+            z.parent = node;
+        }
+        else {
+            const nextNode = leftest(node.right);
+            nextNode.left = z;
+            z.parent = nextNode;
+        }
+        fixInsert(this, z);
+        return z;
+    }
+    /**
+     *      node              node
+     *     /  \              /  \
+     *    a   b     ---->   a    b
+     *                       \
+     *                        z
+     */
+    rbInsertLeft(node, p) {
+        const z = new TreeNode(p, 1 /* NodeColor.Red */);
+        z.left = SENTINEL;
+        z.right = SENTINEL;
+        z.parent = SENTINEL;
+        z.size_left = 0;
+        z.lf_left = 0;
+        if (this.root === SENTINEL) {
+            this.root = z;
+            z.color = 0 /* NodeColor.Black */;
+        }
+        else if (node.left === SENTINEL) {
+            node.left = z;
+            z.parent = node;
+        }
+        else {
+            const prevNode = righttest(node.left); // a
+            prevNode.right = z;
+            z.parent = prevNode;
+        }
+        fixInsert(this, z);
+        return z;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.js

@@ -0,0 +1,455 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Emitter } from '../../../../base/common/event.js';
+import * as strings from '../../../../base/common/strings.js';
+import { Range } from '../../core/range.js';
+import { ApplyEditsResult } from '../../model.js';
+import { PieceTreeBase } from './pieceTreeBase.js';
+import { countEOL } from '../../core/eolCounter.js';
+import { TextChange } from '../../core/textChange.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+export class PieceTreeTextBuffer extends Disposable {
+    constructor(chunks, BOM, eol, containsRTL, containsUnusualLineTerminators, isBasicASCII, eolNormalized) {
+        super();
+        this._onDidChangeContent = this._register(new Emitter());
+        this._BOM = BOM;
+        this._mightContainNonBasicASCII = !isBasicASCII;
+        this._mightContainRTL = containsRTL;
+        this._mightContainUnusualLineTerminators = containsUnusualLineTerminators;
+        this._pieceTree = new PieceTreeBase(chunks, eol, eolNormalized);
+    }
+    mightContainRTL() {
+        return this._mightContainRTL;
+    }
+    mightContainUnusualLineTerminators() {
+        return this._mightContainUnusualLineTerminators;
+    }
+    resetMightContainUnusualLineTerminators() {
+        this._mightContainUnusualLineTerminators = false;
+    }
+    mightContainNonBasicASCII() {
+        return this._mightContainNonBasicASCII;
+    }
+    getBOM() {
+        return this._BOM;
+    }
+    getEOL() {
+        return this._pieceTree.getEOL();
+    }
+    createSnapshot(preserveBOM) {
+        return this._pieceTree.createSnapshot(preserveBOM ? this._BOM : '');
+    }
+    getOffsetAt(lineNumber, column) {
+        return this._pieceTree.getOffsetAt(lineNumber, column);
+    }
+    getPositionAt(offset) {
+        return this._pieceTree.getPositionAt(offset);
+    }
+    getRangeAt(start, length) {
+        const end = start + length;
+        const startPosition = this.getPositionAt(start);
+        const endPosition = this.getPositionAt(end);
+        return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);
+    }
+    getValueInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {
+        if (range.isEmpty()) {
+            return '';
+        }
+        const lineEnding = this._getEndOfLine(eol);
+        return this._pieceTree.getValueInRange(range, lineEnding);
+    }
+    getValueLengthInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {
+        if (range.isEmpty()) {
+            return 0;
+        }
+        if (range.startLineNumber === range.endLineNumber) {
+            return (range.endColumn - range.startColumn);
+        }
+        const startOffset = this.getOffsetAt(range.startLineNumber, range.startColumn);
+        const endOffset = this.getOffsetAt(range.endLineNumber, range.endColumn);
+        // offsets use the text EOL, so we need to compensate for length differences
+        // if the requested EOL doesn't match the text EOL
+        let eolOffsetCompensation = 0;
+        const desiredEOL = this._getEndOfLine(eol);
+        const actualEOL = this.getEOL();
+        if (desiredEOL.length !== actualEOL.length) {
+            const delta = desiredEOL.length - actualEOL.length;
+            const eolCount = range.endLineNumber - range.startLineNumber;
+            eolOffsetCompensation = delta * eolCount;
+        }
+        return endOffset - startOffset + eolOffsetCompensation;
+    }
+    getCharacterCountInRange(range, eol = 0 /* EndOfLinePreference.TextDefined */) {
+        if (this._mightContainNonBasicASCII) {
+            // we must count by iterating
+            let result = 0;
+            const fromLineNumber = range.startLineNumber;
+            const toLineNumber = range.endLineNumber;
+            for (let lineNumber = fromLineNumber; lineNumber <= toLineNumber; lineNumber++) {
+                const lineContent = this.getLineContent(lineNumber);
+                const fromOffset = (lineNumber === fromLineNumber ? range.startColumn - 1 : 0);
+                const toOffset = (lineNumber === toLineNumber ? range.endColumn - 1 : lineContent.length);
+                for (let offset = fromOffset; offset < toOffset; offset++) {
+                    if (strings.isHighSurrogate(lineContent.charCodeAt(offset))) {
+                        result = result + 1;
+                        offset = offset + 1;
+                    }
+                    else {
+                        result = result + 1;
+                    }
+                }
+            }
+            result += this._getEndOfLine(eol).length * (toLineNumber - fromLineNumber);
+            return result;
+        }
+        return this.getValueLengthInRange(range, eol);
+    }
+    getLength() {
+        return this._pieceTree.getLength();
+    }
+    getLineCount() {
+        return this._pieceTree.getLineCount();
+    }
+    getLinesContent() {
+        return this._pieceTree.getLinesContent();
+    }
+    getLineContent(lineNumber) {
+        return this._pieceTree.getLineContent(lineNumber);
+    }
+    getLineCharCode(lineNumber, index) {
+        return this._pieceTree.getLineCharCode(lineNumber, index);
+    }
+    getLineLength(lineNumber) {
+        return this._pieceTree.getLineLength(lineNumber);
+    }
+    getLineFirstNonWhitespaceColumn(lineNumber) {
+        const result = strings.firstNonWhitespaceIndex(this.getLineContent(lineNumber));
+        if (result === -1) {
+            return 0;
+        }
+        return result + 1;
+    }
+    getLineLastNonWhitespaceColumn(lineNumber) {
+        const result = strings.lastNonWhitespaceIndex(this.getLineContent(lineNumber));
+        if (result === -1) {
+            return 0;
+        }
+        return result + 2;
+    }
+    _getEndOfLine(eol) {
+        switch (eol) {
+            case 1 /* EndOfLinePreference.LF */:
+                return '\n';
+            case 2 /* EndOfLinePreference.CRLF */:
+                return '\r\n';
+            case 0 /* EndOfLinePreference.TextDefined */:
+                return this.getEOL();
+            default:
+                throw new Error('Unknown EOL preference');
+        }
+    }
+    setEOL(newEOL) {
+        this._pieceTree.setEOL(newEOL);
+    }
+    applyEdits(rawOperations, recordTrimAutoWhitespace, computeUndoEdits) {
+        let mightContainRTL = this._mightContainRTL;
+        let mightContainUnusualLineTerminators = this._mightContainUnusualLineTerminators;
+        let mightContainNonBasicASCII = this._mightContainNonBasicASCII;
+        let canReduceOperations = true;
+        let operations = [];
+        for (let i = 0; i < rawOperations.length; i++) {
+            const op = rawOperations[i];
+            if (canReduceOperations && op._isTracked) {
+                canReduceOperations = false;
+            }
+            const validatedRange = op.range;
+            if (op.text) {
+                let textMightContainNonBasicASCII = true;
+                if (!mightContainNonBasicASCII) {
+                    textMightContainNonBasicASCII = !strings.isBasicASCII(op.text);
+                    mightContainNonBasicASCII = textMightContainNonBasicASCII;
+                }
+                if (!mightContainRTL && textMightContainNonBasicASCII) {
+                    // check if the new inserted text contains RTL
+                    mightContainRTL = strings.containsRTL(op.text);
+                }
+                if (!mightContainUnusualLineTerminators && textMightContainNonBasicASCII) {
+                    // check if the new inserted text contains unusual line terminators
+                    mightContainUnusualLineTerminators = strings.containsUnusualLineTerminators(op.text);
+                }
+            }
+            let validText = '';
+            let eolCount = 0;
+            let firstLineLength = 0;
+            let lastLineLength = 0;
+            if (op.text) {
+                let strEOL;
+                [eolCount, firstLineLength, lastLineLength, strEOL] = countEOL(op.text);
+                const bufferEOL = this.getEOL();
+                const expectedStrEOL = (bufferEOL === '\r\n' ? 2 /* StringEOL.CRLF */ : 1 /* StringEOL.LF */);
+                if (strEOL === 0 /* StringEOL.Unknown */ || strEOL === expectedStrEOL) {
+                    validText = op.text;
+                }
+                else {
+                    validText = op.text.replace(/\r\n|\r|\n/g, bufferEOL);
+                }
+            }
+            operations[i] = {
+                sortIndex: i,
+                identifier: op.identifier || null,
+                range: validatedRange,
+                rangeOffset: this.getOffsetAt(validatedRange.startLineNumber, validatedRange.startColumn),
+                rangeLength: this.getValueLengthInRange(validatedRange),
+                text: validText,
+                eolCount: eolCount,
+                firstLineLength: firstLineLength,
+                lastLineLength: lastLineLength,
+                forceMoveMarkers: Boolean(op.forceMoveMarkers),
+                isAutoWhitespaceEdit: op.isAutoWhitespaceEdit || false
+            };
+        }
+        // Sort operations ascending
+        operations.sort(PieceTreeTextBuffer._sortOpsAscending);
+        let hasTouchingRanges = false;
+        for (let i = 0, count = operations.length - 1; i < count; i++) {
+            const rangeEnd = operations[i].range.getEndPosition();
+            const nextRangeStart = operations[i + 1].range.getStartPosition();
+            if (nextRangeStart.isBeforeOrEqual(rangeEnd)) {
+                if (nextRangeStart.isBefore(rangeEnd)) {
+                    // overlapping ranges
+                    throw new Error('Overlapping ranges are not allowed!');
+                }
+                hasTouchingRanges = true;
+            }
+        }
+        if (canReduceOperations) {
+            operations = this._reduceOperations(operations);
+        }
+        // Delta encode operations
+        const reverseRanges = (computeUndoEdits || recordTrimAutoWhitespace ? PieceTreeTextBuffer._getInverseEditRanges(operations) : []);
+        const newTrimAutoWhitespaceCandidates = [];
+        if (recordTrimAutoWhitespace) {
+            for (let i = 0; i < operations.length; i++) {
+                const op = operations[i];
+                const reverseRange = reverseRanges[i];
+                if (op.isAutoWhitespaceEdit && op.range.isEmpty()) {
+                    // Record already the future line numbers that might be auto whitespace removal candidates on next edit
+                    for (let lineNumber = reverseRange.startLineNumber; lineNumber <= reverseRange.endLineNumber; lineNumber++) {
+                        let currentLineContent = '';
+                        if (lineNumber === reverseRange.startLineNumber) {
+                            currentLineContent = this.getLineContent(op.range.startLineNumber);
+                            if (strings.firstNonWhitespaceIndex(currentLineContent) !== -1) {
+                                continue;
+                            }
+                        }
+                        newTrimAutoWhitespaceCandidates.push({ lineNumber: lineNumber, oldContent: currentLineContent });
+                    }
+                }
+            }
+        }
+        let reverseOperations = null;
+        if (computeUndoEdits) {
+            let reverseRangeDeltaOffset = 0;
+            reverseOperations = [];
+            for (let i = 0; i < operations.length; i++) {
+                const op = operations[i];
+                const reverseRange = reverseRanges[i];
+                const bufferText = this.getValueInRange(op.range);
+                const reverseRangeOffset = op.rangeOffset + reverseRangeDeltaOffset;
+                reverseRangeDeltaOffset += (op.text.length - bufferText.length);
+                reverseOperations[i] = {
+                    sortIndex: op.sortIndex,
+                    identifier: op.identifier,
+                    range: reverseRange,
+                    text: bufferText,
+                    textChange: new TextChange(op.rangeOffset, bufferText, reverseRangeOffset, op.text)
+                };
+            }
+            // Can only sort reverse operations when the order is not significant
+            if (!hasTouchingRanges) {
+                reverseOperations.sort((a, b) => a.sortIndex - b.sortIndex);
+            }
+        }
+        this._mightContainRTL = mightContainRTL;
+        this._mightContainUnusualLineTerminators = mightContainUnusualLineTerminators;
+        this._mightContainNonBasicASCII = mightContainNonBasicASCII;
+        const contentChanges = this._doApplyEdits(operations);
+        let trimAutoWhitespaceLineNumbers = null;
+        if (recordTrimAutoWhitespace && newTrimAutoWhitespaceCandidates.length > 0) {
+            // sort line numbers auto whitespace removal candidates for next edit descending
+            newTrimAutoWhitespaceCandidates.sort((a, b) => b.lineNumber - a.lineNumber);
+            trimAutoWhitespaceLineNumbers = [];
+            for (let i = 0, len = newTrimAutoWhitespaceCandidates.length; i < len; i++) {
+                const lineNumber = newTrimAutoWhitespaceCandidates[i].lineNumber;
+                if (i > 0 && newTrimAutoWhitespaceCandidates[i - 1].lineNumber === lineNumber) {
+                    // Do not have the same line number twice
+                    continue;
+                }
+                const prevContent = newTrimAutoWhitespaceCandidates[i].oldContent;
+                const lineContent = this.getLineContent(lineNumber);
+                if (lineContent.length === 0 || lineContent === prevContent || strings.firstNonWhitespaceIndex(lineContent) !== -1) {
+                    continue;
+                }
+                trimAutoWhitespaceLineNumbers.push(lineNumber);
+            }
+        }
+        this._onDidChangeContent.fire();
+        return new ApplyEditsResult(reverseOperations, contentChanges, trimAutoWhitespaceLineNumbers);
+    }
+    /**
+     * Transform operations such that they represent the same logic edit,
+     * but that they also do not cause OOM crashes.
+     */
+    _reduceOperations(operations) {
+        if (operations.length < 1000) {
+            // We know from empirical testing that a thousand edits work fine regardless of their shape.
+            return operations;
+        }
+        // At one point, due to how events are emitted and how each operation is handled,
+        // some operations can trigger a high amount of temporary string allocations,
+        // that will immediately get edited again.
+        // e.g. a formatter inserting ridiculous ammounts of \n on a model with a single line
+        // Therefore, the strategy is to collapse all the operations into a huge single edit operation
+        return [this._toSingleEditOperation(operations)];
+    }
+    _toSingleEditOperation(operations) {
+        let forceMoveMarkers = false;
+        const firstEditRange = operations[0].range;
+        const lastEditRange = operations[operations.length - 1].range;
+        const entireEditRange = new Range(firstEditRange.startLineNumber, firstEditRange.startColumn, lastEditRange.endLineNumber, lastEditRange.endColumn);
+        let lastEndLineNumber = firstEditRange.startLineNumber;
+        let lastEndColumn = firstEditRange.startColumn;
+        const result = [];
+        for (let i = 0, len = operations.length; i < len; i++) {
+            const operation = operations[i];
+            const range = operation.range;
+            forceMoveMarkers = forceMoveMarkers || operation.forceMoveMarkers;
+            // (1) -- Push old text
+            result.push(this.getValueInRange(new Range(lastEndLineNumber, lastEndColumn, range.startLineNumber, range.startColumn)));
+            // (2) -- Push new text
+            if (operation.text.length > 0) {
+                result.push(operation.text);
+            }
+            lastEndLineNumber = range.endLineNumber;
+            lastEndColumn = range.endColumn;
+        }
+        const text = result.join('');
+        const [eolCount, firstLineLength, lastLineLength] = countEOL(text);
+        return {
+            sortIndex: 0,
+            identifier: operations[0].identifier,
+            range: entireEditRange,
+            rangeOffset: this.getOffsetAt(entireEditRange.startLineNumber, entireEditRange.startColumn),
+            rangeLength: this.getValueLengthInRange(entireEditRange, 0 /* EndOfLinePreference.TextDefined */),
+            text: text,
+            eolCount: eolCount,
+            firstLineLength: firstLineLength,
+            lastLineLength: lastLineLength,
+            forceMoveMarkers: forceMoveMarkers,
+            isAutoWhitespaceEdit: false
+        };
+    }
+    _doApplyEdits(operations) {
+        operations.sort(PieceTreeTextBuffer._sortOpsDescending);
+        const contentChanges = [];
+        // operations are from bottom to top
+        for (let i = 0; i < operations.length; i++) {
+            const op = operations[i];
+            const startLineNumber = op.range.startLineNumber;
+            const startColumn = op.range.startColumn;
+            const endLineNumber = op.range.endLineNumber;
+            const endColumn = op.range.endColumn;
+            if (startLineNumber === endLineNumber && startColumn === endColumn && op.text.length === 0) {
+                // no-op
+                continue;
+            }
+            if (op.text) {
+                // replacement
+                this._pieceTree.delete(op.rangeOffset, op.rangeLength);
+                this._pieceTree.insert(op.rangeOffset, op.text, true);
+            }
+            else {
+                // deletion
+                this._pieceTree.delete(op.rangeOffset, op.rangeLength);
+            }
+            const contentChangeRange = new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+            contentChanges.push({
+                range: contentChangeRange,
+                rangeLength: op.rangeLength,
+                text: op.text,
+                rangeOffset: op.rangeOffset,
+                forceMoveMarkers: op.forceMoveMarkers
+            });
+        }
+        return contentChanges;
+    }
+    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {
+        return this._pieceTree.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);
+    }
+    /**
+     * Assumes `operations` are validated and sorted ascending
+     */
+    static _getInverseEditRanges(operations) {
+        const result = [];
+        let prevOpEndLineNumber = 0;
+        let prevOpEndColumn = 0;
+        let prevOp = null;
+        for (let i = 0, len = operations.length; i < len; i++) {
+            const op = operations[i];
+            let startLineNumber;
+            let startColumn;
+            if (prevOp) {
+                if (prevOp.range.endLineNumber === op.range.startLineNumber) {
+                    startLineNumber = prevOpEndLineNumber;
+                    startColumn = prevOpEndColumn + (op.range.startColumn - prevOp.range.endColumn);
+                }
+                else {
+                    startLineNumber = prevOpEndLineNumber + (op.range.startLineNumber - prevOp.range.endLineNumber);
+                    startColumn = op.range.startColumn;
+                }
+            }
+            else {
+                startLineNumber = op.range.startLineNumber;
+                startColumn = op.range.startColumn;
+            }
+            let resultRange;
+            if (op.text.length > 0) {
+                // the operation inserts something
+                const lineCount = op.eolCount + 1;
+                if (lineCount === 1) {
+                    // single line insert
+                    resultRange = new Range(startLineNumber, startColumn, startLineNumber, startColumn + op.firstLineLength);
+                }
+                else {
+                    // multi line insert
+                    resultRange = new Range(startLineNumber, startColumn, startLineNumber + lineCount - 1, op.lastLineLength + 1);
+                }
+            }
+            else {
+                // There is nothing to insert
+                resultRange = new Range(startLineNumber, startColumn, startLineNumber, startColumn);
+            }
+            prevOpEndLineNumber = resultRange.endLineNumber;
+            prevOpEndColumn = resultRange.endColumn;
+            result.push(resultRange);
+            prevOp = op;
+        }
+        return result;
+    }
+    static _sortOpsAscending(a, b) {
+        const r = Range.compareRangesUsingEnds(a.range, b.range);
+        if (r === 0) {
+            return a.sortIndex - b.sortIndex;
+        }
+        return r;
+    }
+    static _sortOpsDescending(a, b) {
+        const r = Range.compareRangesUsingEnds(a.range, b.range);
+        if (r === 0) {
+            return b.sortIndex - a.sortIndex;
+        }
+        return -r;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as strings from '../../../../base/common/strings.js';
+import { StringBuffer, createLineStarts, createLineStartsFast } from './pieceTreeBase.js';
+import { PieceTreeTextBuffer } from './pieceTreeTextBuffer.js';
+class PieceTreeTextBufferFactory {
+    constructor(_chunks, _bom, _cr, _lf, _crlf, _containsRTL, _containsUnusualLineTerminators, _isBasicASCII, _normalizeEOL) {
+        this._chunks = _chunks;
+        this._bom = _bom;
+        this._cr = _cr;
+        this._lf = _lf;
+        this._crlf = _crlf;
+        this._containsRTL = _containsRTL;
+        this._containsUnusualLineTerminators = _containsUnusualLineTerminators;
+        this._isBasicASCII = _isBasicASCII;
+        this._normalizeEOL = _normalizeEOL;
+    }
+    _getEOL(defaultEOL) {
+        const totalEOLCount = this._cr + this._lf + this._crlf;
+        const totalCRCount = this._cr + this._crlf;
+        if (totalEOLCount === 0) {
+            // This is an empty file or a file with precisely one line
+            return (defaultEOL === 1 /* DefaultEndOfLine.LF */ ? '\n' : '\r\n');
+        }
+        if (totalCRCount > totalEOLCount / 2) {
+            // More than half of the file contains \r\n ending lines
+            return '\r\n';
+        }
+        // At least one line more ends in \n
+        return '\n';
+    }
+    create(defaultEOL) {
+        const eol = this._getEOL(defaultEOL);
+        const chunks = this._chunks;
+        if (this._normalizeEOL &&
+            ((eol === '\r\n' && (this._cr > 0 || this._lf > 0))
+                || (eol === '\n' && (this._cr > 0 || this._crlf > 0)))) {
+            // Normalize pieces
+            for (let i = 0, len = chunks.length; i < len; i++) {
+                const str = chunks[i].buffer.replace(/\r\n|\r|\n/g, eol);
+                const newLineStart = createLineStartsFast(str);
+                chunks[i] = new StringBuffer(str, newLineStart);
+            }
+        }
+        const textBuffer = new PieceTreeTextBuffer(chunks, this._bom, eol, this._containsRTL, this._containsUnusualLineTerminators, this._isBasicASCII, this._normalizeEOL);
+        return { textBuffer: textBuffer, disposable: textBuffer };
+    }
+}
+export class PieceTreeTextBufferBuilder {
+    constructor() {
+        this.chunks = [];
+        this.BOM = '';
+        this._hasPreviousChar = false;
+        this._previousChar = 0;
+        this._tmpLineStarts = [];
+        this.cr = 0;
+        this.lf = 0;
+        this.crlf = 0;
+        this.containsRTL = false;
+        this.containsUnusualLineTerminators = false;
+        this.isBasicASCII = true;
+    }
+    acceptChunk(chunk) {
+        if (chunk.length === 0) {
+            return;
+        }
+        if (this.chunks.length === 0) {
+            if (strings.startsWithUTF8BOM(chunk)) {
+                this.BOM = strings.UTF8_BOM_CHARACTER;
+                chunk = chunk.substr(1);
+            }
+        }
+        const lastChar = chunk.charCodeAt(chunk.length - 1);
+        if (lastChar === 13 /* CharCode.CarriageReturn */ || (lastChar >= 0xD800 && lastChar <= 0xDBFF)) {
+            // last character is \r or a high surrogate => keep it back
+            this._acceptChunk1(chunk.substr(0, chunk.length - 1), false);
+            this._hasPreviousChar = true;
+            this._previousChar = lastChar;
+        }
+        else {
+            this._acceptChunk1(chunk, false);
+            this._hasPreviousChar = false;
+            this._previousChar = lastChar;
+        }
+    }
+    _acceptChunk1(chunk, allowEmptyStrings) {
+        if (!allowEmptyStrings && chunk.length === 0) {
+            // Nothing to do
+            return;
+        }
+        if (this._hasPreviousChar) {
+            this._acceptChunk2(String.fromCharCode(this._previousChar) + chunk);
+        }
+        else {
+            this._acceptChunk2(chunk);
+        }
+    }
+    _acceptChunk2(chunk) {
+        const lineStarts = createLineStarts(this._tmpLineStarts, chunk);
+        this.chunks.push(new StringBuffer(chunk, lineStarts.lineStarts));
+        this.cr += lineStarts.cr;
+        this.lf += lineStarts.lf;
+        this.crlf += lineStarts.crlf;
+        if (!lineStarts.isBasicASCII) {
+            // this chunk contains non basic ASCII characters
+            this.isBasicASCII = false;
+            if (!this.containsRTL) {
+                this.containsRTL = strings.containsRTL(chunk);
+            }
+            if (!this.containsUnusualLineTerminators) {
+                this.containsUnusualLineTerminators = strings.containsUnusualLineTerminators(chunk);
+            }
+        }
+    }
+    finish(normalizeEOL = true) {
+        this._finish();
+        return new PieceTreeTextBufferFactory(this.chunks, this.BOM, this.cr, this.lf, this.crlf, this.containsRTL, this.containsUnusualLineTerminators, this.isBasicASCII, normalizeEOL);
+    }
+    _finish() {
+        if (this.chunks.length === 0) {
+            this._acceptChunk1('', true);
+        }
+        if (this._hasPreviousChar) {
+            this._hasPreviousChar = false;
+            // recreate last chunk
+            const lastChunk = this.chunks[this.chunks.length - 1];
+            lastChunk.buffer += String.fromCharCode(this._previousChar);
+            const newLineStarts = createLineStartsFast(lastChunk.buffer);
+            lastChunk.lineStarts = newLineStarts;
+            if (this._previousChar === 13 /* CharCode.CarriageReturn */) {
+                this.cr++;
+            }
+        }
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/rbTreeBase.js

@@ -0,0 +1,360 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export 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;
+    }
+}
+export const SENTINEL = new TreeNode(null, 0 /* NodeColor.Black */);
+SENTINEL.parent = SENTINEL;
+SENTINEL.left = SENTINEL;
+SENTINEL.right = SENTINEL;
+SENTINEL.color = 0 /* NodeColor.Black */;
+export function leftest(node) {
+    while (node.left !== SENTINEL) {
+        node = node.left;
+    }
+    return node;
+}
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export 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();
+}
+export 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 */;
+}
+export 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;
+    }
+}
+export 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;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/prefixSumComputer.js

@@ -0,0 +1,223 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { arrayInsert } from '../../../base/common/arrays.js';
+import { toUint32 } from '../../../base/common/uint.js';
+export class PrefixSumComputer {
+    constructor(values) {
+        this.values = values;
+        this.prefixSum = new Uint32Array(values.length);
+        this.prefixSumValidIndex = new Int32Array(1);
+        this.prefixSumValidIndex[0] = -1;
+    }
+    insertValues(insertIndex, insertValues) {
+        insertIndex = toUint32(insertIndex);
+        const oldValues = this.values;
+        const oldPrefixSum = this.prefixSum;
+        const insertValuesLen = insertValues.length;
+        if (insertValuesLen === 0) {
+            return false;
+        }
+        this.values = new Uint32Array(oldValues.length + insertValuesLen);
+        this.values.set(oldValues.subarray(0, insertIndex), 0);
+        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);
+        this.values.set(insertValues, insertIndex);
+        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {
+            this.prefixSumValidIndex[0] = insertIndex - 1;
+        }
+        this.prefixSum = new Uint32Array(this.values.length);
+        if (this.prefixSumValidIndex[0] >= 0) {
+            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
+        }
+        return true;
+    }
+    setValue(index, value) {
+        index = toUint32(index);
+        value = toUint32(value);
+        if (this.values[index] === value) {
+            return false;
+        }
+        this.values[index] = value;
+        if (index - 1 < this.prefixSumValidIndex[0]) {
+            this.prefixSumValidIndex[0] = index - 1;
+        }
+        return true;
+    }
+    removeValues(startIndex, count) {
+        startIndex = toUint32(startIndex);
+        count = toUint32(count);
+        const oldValues = this.values;
+        const oldPrefixSum = this.prefixSum;
+        if (startIndex >= oldValues.length) {
+            return false;
+        }
+        const maxCount = oldValues.length - startIndex;
+        if (count >= maxCount) {
+            count = maxCount;
+        }
+        if (count === 0) {
+            return false;
+        }
+        this.values = new Uint32Array(oldValues.length - count);
+        this.values.set(oldValues.subarray(0, startIndex), 0);
+        this.values.set(oldValues.subarray(startIndex + count), startIndex);
+        this.prefixSum = new Uint32Array(this.values.length);
+        if (startIndex - 1 < this.prefixSumValidIndex[0]) {
+            this.prefixSumValidIndex[0] = startIndex - 1;
+        }
+        if (this.prefixSumValidIndex[0] >= 0) {
+            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
+        }
+        return true;
+    }
+    getTotalSum() {
+        if (this.values.length === 0) {
+            return 0;
+        }
+        return this._getPrefixSum(this.values.length - 1);
+    }
+    /**
+     * Returns the sum of the first `index + 1` many items.
+     * @returns `SUM(0 <= j <= index, values[j])`.
+     */
+    getPrefixSum(index) {
+        if (index < 0) {
+            return 0;
+        }
+        index = toUint32(index);
+        return this._getPrefixSum(index);
+    }
+    _getPrefixSum(index) {
+        if (index <= this.prefixSumValidIndex[0]) {
+            return this.prefixSum[index];
+        }
+        let startIndex = this.prefixSumValidIndex[0] + 1;
+        if (startIndex === 0) {
+            this.prefixSum[0] = this.values[0];
+            startIndex++;
+        }
+        if (index >= this.values.length) {
+            index = this.values.length - 1;
+        }
+        for (let i = startIndex; i <= index; i++) {
+            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];
+        }
+        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);
+        return this.prefixSum[index];
+    }
+    getIndexOf(sum) {
+        sum = Math.floor(sum);
+        // Compute all sums (to get a fully valid prefixSum)
+        this.getTotalSum();
+        let low = 0;
+        let high = this.values.length - 1;
+        let mid = 0;
+        let midStop = 0;
+        let midStart = 0;
+        while (low <= high) {
+            mid = low + ((high - low) / 2) | 0;
+            midStop = this.prefixSum[mid];
+            midStart = midStop - this.values[mid];
+            if (sum < midStart) {
+                high = mid - 1;
+            }
+            else if (sum >= midStop) {
+                low = mid + 1;
+            }
+            else {
+                break;
+            }
+        }
+        return new PrefixSumIndexOfResult(mid, sum - midStart);
+    }
+}
+/**
+ * {@link getIndexOf} has an amortized runtime complexity of O(1).
+ *
+ * ({@link PrefixSumComputer.getIndexOf} is just  O(log n))
+*/
+export class ConstantTimePrefixSumComputer {
+    constructor(values) {
+        this._values = values;
+        this._isValid = false;
+        this._validEndIndex = -1;
+        this._prefixSum = [];
+        this._indexBySum = [];
+    }
+    /**
+     * @returns SUM(0 <= j < values.length, values[j])
+     */
+    getTotalSum() {
+        this._ensureValid();
+        return this._indexBySum.length;
+    }
+    /**
+     * Returns the sum of the first `count` many items.
+     * @returns `SUM(0 <= j < count, values[j])`.
+     */
+    getPrefixSum(count) {
+        this._ensureValid();
+        if (count === 0) {
+            return 0;
+        }
+        return this._prefixSum[count - 1];
+    }
+    /**
+     * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`
+     */
+    getIndexOf(sum) {
+        this._ensureValid();
+        const idx = this._indexBySum[sum];
+        const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;
+        return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove);
+    }
+    removeValues(start, deleteCount) {
+        this._values.splice(start, deleteCount);
+        this._invalidate(start);
+    }
+    insertValues(insertIndex, insertArr) {
+        this._values = arrayInsert(this._values, insertIndex, insertArr);
+        this._invalidate(insertIndex);
+    }
+    _invalidate(index) {
+        this._isValid = false;
+        this._validEndIndex = Math.min(this._validEndIndex, index - 1);
+    }
+    _ensureValid() {
+        if (this._isValid) {
+            return;
+        }
+        for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) {
+            const value = this._values[i];
+            const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0;
+            this._prefixSum[i] = sumAbove + value;
+            for (let j = 0; j < value; j++) {
+                this._indexBySum[sumAbove + j] = i;
+            }
+        }
+        // trim things
+        this._prefixSum.length = this._values.length;
+        this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];
+        // mark as valid
+        this._isValid = true;
+        this._validEndIndex = this._values.length - 1;
+    }
+    setValue(index, value) {
+        if (this._values[index] === value) {
+            // no change
+            return;
+        }
+        this._values[index] = value;
+        this._invalidate(index);
+    }
+}
+export class PrefixSumIndexOfResult {
+    constructor(index, remainder) {
+        this.index = index;
+        this.remainder = remainder;
+        this._prefixSumIndexOfResultBrand = undefined;
+        this.index = index;
+        this.remainder = remainder;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/textModel.js

@@ -0,0 +1,1899 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var TextModel_1;
+import { ArrayQueue, pushMany } from '../../../base/common/arrays.js';
+import { Color } from '../../../base/common/color.js';
+import { BugIndicatingError, illegalArgument, onUnexpectedError } from '../../../base/common/errors.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, MutableDisposable, combinedDisposable } from '../../../base/common/lifecycle.js';
+import * as strings from '../../../base/common/strings.js';
+import { URI } from '../../../base/common/uri.js';
+import { countEOL } from '../core/eolCounter.js';
+import { normalizeIndentation } from '../core/indentation.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+import { Selection } from '../core/selection.js';
+import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
+import { ILanguageService } from '../languages/language.js';
+import { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.js';
+import * as model from '../model.js';
+import { BracketPairsTextModelPart } from './bracketPairsTextModelPart/bracketPairsImpl.js';
+import { ColorizedBracketPairsDecorationProvider } from './bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js';
+import { EditStack } from './editStack.js';
+import { GuidesTextModelPart } from './guidesTextModelPart.js';
+import { guessIndentation } from './indentationGuesser.js';
+import { IntervalNode, IntervalTree, recomputeMaxEnd } from './intervalTree.js';
+import { PieceTreeTextBuffer } from './pieceTreeTextBuffer/pieceTreeTextBuffer.js';
+import { PieceTreeTextBufferBuilder } from './pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';
+import { SearchParams, TextModelSearch } from './textModelSearch.js';
+import { TokenizationTextModelPart } from './tokenizationTextModelPart.js';
+import { AttachedViews } from './tokens.js';
+import { InternalModelContentChangeEvent, LineInjectedText, ModelInjectedTextChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted } from '../textModelEvents.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
+import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.js';
+export function createTextBufferFactory(text) {
+    const builder = new PieceTreeTextBufferBuilder();
+    builder.acceptChunk(text);
+    return builder.finish();
+}
+export function createTextBufferFactoryFromSnapshot(snapshot) {
+    const builder = new PieceTreeTextBufferBuilder();
+    let chunk;
+    while (typeof (chunk = snapshot.read()) === 'string') {
+        builder.acceptChunk(chunk);
+    }
+    return builder.finish();
+}
+export function createTextBuffer(value, defaultEOL) {
+    let factory;
+    if (typeof value === 'string') {
+        factory = createTextBufferFactory(value);
+    }
+    else if (model.isITextSnapshot(value)) {
+        factory = createTextBufferFactoryFromSnapshot(value);
+    }
+    else {
+        factory = value;
+    }
+    return factory.create(defaultEOL);
+}
+let MODEL_ID = 0;
+const LIMIT_FIND_COUNT = 999;
+const LONG_LINE_BOUNDARY = 10000;
+class TextModelSnapshot {
+    constructor(source) {
+        this._source = source;
+        this._eos = false;
+    }
+    read() {
+        if (this._eos) {
+            return null;
+        }
+        const result = [];
+        let resultCnt = 0;
+        let resultLength = 0;
+        do {
+            const tmp = this._source.read();
+            if (tmp === null) {
+                // end-of-stream
+                this._eos = true;
+                if (resultCnt === 0) {
+                    return null;
+                }
+                else {
+                    return result.join('');
+                }
+            }
+            if (tmp.length > 0) {
+                result[resultCnt++] = tmp;
+                resultLength += tmp.length;
+            }
+            if (resultLength >= 64 * 1024) {
+                return result.join('');
+            }
+        } while (true);
+    }
+}
+const invalidFunc = () => { throw new Error(`Invalid change accessor`); };
+let TextModel = class TextModel extends Disposable {
+    static { TextModel_1 = this; }
+    static { this._MODEL_SYNC_LIMIT = 50 * 1024 * 1024; } // 50 MB,  // used in tests
+    static { this.LARGE_FILE_SIZE_THRESHOLD = 20 * 1024 * 1024; } // 20 MB;
+    static { this.LARGE_FILE_LINE_COUNT_THRESHOLD = 300 * 1000; } // 300K lines
+    static { this.LARGE_FILE_HEAP_OPERATION_THRESHOLD = 256 * 1024 * 1024; } // 256M characters, usually ~> 512MB memory usage
+    static { this.DEFAULT_CREATION_OPTIONS = {
+        isForSimpleWidget: false,
+        tabSize: EDITOR_MODEL_DEFAULTS.tabSize,
+        indentSize: EDITOR_MODEL_DEFAULTS.indentSize,
+        insertSpaces: EDITOR_MODEL_DEFAULTS.insertSpaces,
+        detectIndentation: false,
+        defaultEOL: 1 /* model.DefaultEndOfLine.LF */,
+        trimAutoWhitespace: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
+        largeFileOptimizations: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
+        bracketPairColorizationOptions: EDITOR_MODEL_DEFAULTS.bracketPairColorizationOptions,
+    }; }
+    static resolveOptions(textBuffer, options) {
+        if (options.detectIndentation) {
+            const guessedIndentation = guessIndentation(textBuffer, options.tabSize, options.insertSpaces);
+            return new model.TextModelResolvedOptions({
+                tabSize: guessedIndentation.tabSize,
+                indentSize: 'tabSize', // TODO@Alex: guess indentSize independent of tabSize
+                insertSpaces: guessedIndentation.insertSpaces,
+                trimAutoWhitespace: options.trimAutoWhitespace,
+                defaultEOL: options.defaultEOL,
+                bracketPairColorizationOptions: options.bracketPairColorizationOptions,
+            });
+        }
+        return new model.TextModelResolvedOptions(options);
+    }
+    get onDidChangeLanguage() { return this._tokenizationTextModelPart.onDidChangeLanguage; }
+    get onDidChangeLanguageConfiguration() { return this._tokenizationTextModelPart.onDidChangeLanguageConfiguration; }
+    get onDidChangeTokens() { return this._tokenizationTextModelPart.onDidChangeTokens; }
+    onDidChangeContent(listener) {
+        return this._eventEmitter.slowEvent((e) => listener(e.contentChangedEvent));
+    }
+    onDidChangeContentOrInjectedText(listener) {
+        return combinedDisposable(this._eventEmitter.fastEvent(e => listener(e)), this._onDidChangeInjectedText.event(e => listener(e)));
+    }
+    _isDisposing() { return this.__isDisposing; }
+    get tokenization() { return this._tokenizationTextModelPart; }
+    get bracketPairs() { return this._bracketPairs; }
+    get guides() { return this._guidesTextModelPart; }
+    constructor(source, languageIdOrSelection, creationOptions, associatedResource = null, _undoRedoService, _languageService, _languageConfigurationService, instantiationService) {
+        super();
+        this._undoRedoService = _undoRedoService;
+        this._languageService = _languageService;
+        this._languageConfigurationService = _languageConfigurationService;
+        this.instantiationService = instantiationService;
+        //#region Events
+        this._onWillDispose = this._register(new Emitter());
+        this.onWillDispose = this._onWillDispose.event;
+        this._onDidChangeDecorations = this._register(new DidChangeDecorationsEmitter(affectedInjectedTextLines => this.handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines)));
+        this.onDidChangeDecorations = this._onDidChangeDecorations.event;
+        this._onDidChangeOptions = this._register(new Emitter());
+        this.onDidChangeOptions = this._onDidChangeOptions.event;
+        this._onDidChangeAttached = this._register(new Emitter());
+        this.onDidChangeAttached = this._onDidChangeAttached.event;
+        this._onDidChangeInjectedText = this._register(new Emitter());
+        this._eventEmitter = this._register(new DidChangeContentEmitter());
+        this._languageSelectionListener = this._register(new MutableDisposable());
+        this._deltaDecorationCallCnt = 0;
+        this._attachedViews = new AttachedViews();
+        // Generate a new unique model id
+        MODEL_ID++;
+        this.id = '$model' + MODEL_ID;
+        this.isForSimpleWidget = creationOptions.isForSimpleWidget;
+        if (typeof associatedResource === 'undefined' || associatedResource === null) {
+            this._associatedResource = URI.parse('inmemory://model/' + MODEL_ID);
+        }
+        else {
+            this._associatedResource = associatedResource;
+        }
+        this._attachedEditorCount = 0;
+        const { textBuffer, disposable } = createTextBuffer(source, creationOptions.defaultEOL);
+        this._buffer = textBuffer;
+        this._bufferDisposable = disposable;
+        this._options = TextModel_1.resolveOptions(this._buffer, creationOptions);
+        const languageId = (typeof languageIdOrSelection === 'string' ? languageIdOrSelection : languageIdOrSelection.languageId);
+        if (typeof languageIdOrSelection !== 'string') {
+            this._languageSelectionListener.value = languageIdOrSelection.onDidChange(() => this._setLanguage(languageIdOrSelection.languageId));
+        }
+        this._bracketPairs = this._register(new BracketPairsTextModelPart(this, this._languageConfigurationService));
+        this._guidesTextModelPart = this._register(new GuidesTextModelPart(this, this._languageConfigurationService));
+        this._decorationProvider = this._register(new ColorizedBracketPairsDecorationProvider(this));
+        this._tokenizationTextModelPart = this.instantiationService.createInstance(TokenizationTextModelPart, this, this._bracketPairs, languageId, this._attachedViews);
+        const bufferLineCount = this._buffer.getLineCount();
+        const bufferTextLength = this._buffer.getValueLengthInRange(new Range(1, 1, bufferLineCount, this._buffer.getLineLength(bufferLineCount) + 1), 0 /* model.EndOfLinePreference.TextDefined */);
+        // !!! Make a decision in the ctor and permanently respect this decision !!!
+        // If a model is too large at construction time, it will never get tokenized,
+        // under no circumstances.
+        if (creationOptions.largeFileOptimizations) {
+            this._isTooLargeForTokenization = ((bufferTextLength > TextModel_1.LARGE_FILE_SIZE_THRESHOLD)
+                || (bufferLineCount > TextModel_1.LARGE_FILE_LINE_COUNT_THRESHOLD));
+            this._isTooLargeForHeapOperation = bufferTextLength > TextModel_1.LARGE_FILE_HEAP_OPERATION_THRESHOLD;
+        }
+        else {
+            this._isTooLargeForTokenization = false;
+            this._isTooLargeForHeapOperation = false;
+        }
+        this._isTooLargeForSyncing = (bufferTextLength > TextModel_1._MODEL_SYNC_LIMIT);
+        this._versionId = 1;
+        this._alternativeVersionId = 1;
+        this._initialUndoRedoSnapshot = null;
+        this._isDisposed = false;
+        this.__isDisposing = false;
+        this._instanceId = strings.singleLetterHash(MODEL_ID);
+        this._lastDecorationId = 0;
+        this._decorations = Object.create(null);
+        this._decorationsTree = new DecorationsTrees();
+        this._commandManager = new EditStack(this, this._undoRedoService);
+        this._isUndoing = false;
+        this._isRedoing = false;
+        this._trimAutoWhitespaceLines = null;
+        this._register(this._decorationProvider.onDidChange(() => {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._onDidChangeDecorations.fire();
+            this._onDidChangeDecorations.endDeferredEmit();
+        }));
+        this._languageService.requestRichLanguageFeatures(languageId);
+        this._register(this._languageConfigurationService.onDidChange(e => {
+            this._bracketPairs.handleLanguageConfigurationServiceChange(e);
+            this._tokenizationTextModelPart.handleLanguageConfigurationServiceChange(e);
+        }));
+    }
+    dispose() {
+        this.__isDisposing = true;
+        this._onWillDispose.fire();
+        this._tokenizationTextModelPart.dispose();
+        this._isDisposed = true;
+        super.dispose();
+        this._bufferDisposable.dispose();
+        this.__isDisposing = false;
+        // Manually release reference to previous text buffer to avoid large leaks
+        // in case someone leaks a TextModel reference
+        const emptyDisposedTextBuffer = new PieceTreeTextBuffer([], '', '\n', false, false, true, true);
+        emptyDisposedTextBuffer.dispose();
+        this._buffer = emptyDisposedTextBuffer;
+        this._bufferDisposable = Disposable.None;
+    }
+    _assertNotDisposed() {
+        if (this._isDisposed) {
+            throw new BugIndicatingError('Model is disposed!');
+        }
+    }
+    _emitContentChangedEvent(rawChange, change) {
+        if (this.__isDisposing) {
+            // Do not confuse listeners by emitting any event after disposing
+            return;
+        }
+        this._tokenizationTextModelPart.handleDidChangeContent(change);
+        this._bracketPairs.handleDidChangeContent(change);
+        this._eventEmitter.fire(new InternalModelContentChangeEvent(rawChange, change));
+    }
+    setValue(value) {
+        this._assertNotDisposed();
+        if (value === null || value === undefined) {
+            throw illegalArgument();
+        }
+        const { textBuffer, disposable } = createTextBuffer(value, this._options.defaultEOL);
+        this._setValueFromTextBuffer(textBuffer, disposable);
+    }
+    _createContentChanged2(range, rangeOffset, rangeLength, text, isUndoing, isRedoing, isFlush, isEolChange) {
+        return {
+            changes: [{
+                    range: range,
+                    rangeOffset: rangeOffset,
+                    rangeLength: rangeLength,
+                    text: text,
+                }],
+            eol: this._buffer.getEOL(),
+            isEolChange: isEolChange,
+            versionId: this.getVersionId(),
+            isUndoing: isUndoing,
+            isRedoing: isRedoing,
+            isFlush: isFlush
+        };
+    }
+    _setValueFromTextBuffer(textBuffer, textBufferDisposable) {
+        this._assertNotDisposed();
+        const oldFullModelRange = this.getFullModelRange();
+        const oldModelValueLength = this.getValueLengthInRange(oldFullModelRange);
+        const endLineNumber = this.getLineCount();
+        const endColumn = this.getLineMaxColumn(endLineNumber);
+        this._buffer = textBuffer;
+        this._bufferDisposable.dispose();
+        this._bufferDisposable = textBufferDisposable;
+        this._increaseVersionId();
+        // Destroy all my decorations
+        this._decorations = Object.create(null);
+        this._decorationsTree = new DecorationsTrees();
+        // Destroy my edit history and settings
+        this._commandManager.clear();
+        this._trimAutoWhitespaceLines = null;
+        this._emitContentChangedEvent(new ModelRawContentChangedEvent([
+            new ModelRawFlush()
+        ], this._versionId, false, false), this._createContentChanged2(new Range(1, 1, endLineNumber, endColumn), 0, oldModelValueLength, this.getValue(), false, false, true, false));
+    }
+    setEOL(eol) {
+        this._assertNotDisposed();
+        const newEOL = (eol === 1 /* model.EndOfLineSequence.CRLF */ ? '\r\n' : '\n');
+        if (this._buffer.getEOL() === newEOL) {
+            // Nothing to do
+            return;
+        }
+        const oldFullModelRange = this.getFullModelRange();
+        const oldModelValueLength = this.getValueLengthInRange(oldFullModelRange);
+        const endLineNumber = this.getLineCount();
+        const endColumn = this.getLineMaxColumn(endLineNumber);
+        this._onBeforeEOLChange();
+        this._buffer.setEOL(newEOL);
+        this._increaseVersionId();
+        this._onAfterEOLChange();
+        this._emitContentChangedEvent(new ModelRawContentChangedEvent([
+            new ModelRawEOLChanged()
+        ], this._versionId, false, false), this._createContentChanged2(new Range(1, 1, endLineNumber, endColumn), 0, oldModelValueLength, this.getValue(), false, false, false, true));
+    }
+    _onBeforeEOLChange() {
+        // Ensure all decorations get their `range` set.
+        this._decorationsTree.ensureAllNodesHaveRanges(this);
+    }
+    _onAfterEOLChange() {
+        // Transform back `range` to offsets
+        const versionId = this.getVersionId();
+        const allDecorations = this._decorationsTree.collectNodesPostOrder();
+        for (let i = 0, len = allDecorations.length; i < len; i++) {
+            const node = allDecorations[i];
+            const range = node.range; // the range is defined due to `_onBeforeEOLChange`
+            const delta = node.cachedAbsoluteStart - node.start;
+            const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);
+            const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);
+            node.cachedAbsoluteStart = startOffset;
+            node.cachedAbsoluteEnd = endOffset;
+            node.cachedVersionId = versionId;
+            node.start = startOffset - delta;
+            node.end = endOffset - delta;
+            recomputeMaxEnd(node);
+        }
+    }
+    onBeforeAttached() {
+        this._attachedEditorCount++;
+        if (this._attachedEditorCount === 1) {
+            this._tokenizationTextModelPart.handleDidChangeAttached();
+            this._onDidChangeAttached.fire(undefined);
+        }
+        return this._attachedViews.attachView();
+    }
+    onBeforeDetached(view) {
+        this._attachedEditorCount--;
+        if (this._attachedEditorCount === 0) {
+            this._tokenizationTextModelPart.handleDidChangeAttached();
+            this._onDidChangeAttached.fire(undefined);
+        }
+        this._attachedViews.detachView(view);
+    }
+    isAttachedToEditor() {
+        return this._attachedEditorCount > 0;
+    }
+    getAttachedEditorCount() {
+        return this._attachedEditorCount;
+    }
+    isTooLargeForSyncing() {
+        return this._isTooLargeForSyncing;
+    }
+    isTooLargeForTokenization() {
+        return this._isTooLargeForTokenization;
+    }
+    isTooLargeForHeapOperation() {
+        return this._isTooLargeForHeapOperation;
+    }
+    isDisposed() {
+        return this._isDisposed;
+    }
+    isDominatedByLongLines() {
+        this._assertNotDisposed();
+        if (this.isTooLargeForTokenization()) {
+            // Cannot word wrap huge files anyways, so it doesn't really matter
+            return false;
+        }
+        let smallLineCharCount = 0;
+        let longLineCharCount = 0;
+        const lineCount = this._buffer.getLineCount();
+        for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+            const lineLength = this._buffer.getLineLength(lineNumber);
+            if (lineLength >= LONG_LINE_BOUNDARY) {
+                longLineCharCount += lineLength;
+            }
+            else {
+                smallLineCharCount += lineLength;
+            }
+        }
+        return (longLineCharCount > smallLineCharCount);
+    }
+    get uri() {
+        return this._associatedResource;
+    }
+    //#region Options
+    getOptions() {
+        this._assertNotDisposed();
+        return this._options;
+    }
+    getFormattingOptions() {
+        return {
+            tabSize: this._options.indentSize,
+            insertSpaces: this._options.insertSpaces
+        };
+    }
+    updateOptions(_newOpts) {
+        this._assertNotDisposed();
+        const tabSize = (typeof _newOpts.tabSize !== 'undefined') ? _newOpts.tabSize : this._options.tabSize;
+        const indentSize = (typeof _newOpts.indentSize !== 'undefined') ? _newOpts.indentSize : this._options.originalIndentSize;
+        const insertSpaces = (typeof _newOpts.insertSpaces !== 'undefined') ? _newOpts.insertSpaces : this._options.insertSpaces;
+        const trimAutoWhitespace = (typeof _newOpts.trimAutoWhitespace !== 'undefined') ? _newOpts.trimAutoWhitespace : this._options.trimAutoWhitespace;
+        const bracketPairColorizationOptions = (typeof _newOpts.bracketColorizationOptions !== 'undefined') ? _newOpts.bracketColorizationOptions : this._options.bracketPairColorizationOptions;
+        const newOpts = new model.TextModelResolvedOptions({
+            tabSize: tabSize,
+            indentSize: indentSize,
+            insertSpaces: insertSpaces,
+            defaultEOL: this._options.defaultEOL,
+            trimAutoWhitespace: trimAutoWhitespace,
+            bracketPairColorizationOptions,
+        });
+        if (this._options.equals(newOpts)) {
+            return;
+        }
+        const e = this._options.createChangeEvent(newOpts);
+        this._options = newOpts;
+        this._bracketPairs.handleDidChangeOptions(e);
+        this._decorationProvider.handleDidChangeOptions(e);
+        this._onDidChangeOptions.fire(e);
+    }
+    detectIndentation(defaultInsertSpaces, defaultTabSize) {
+        this._assertNotDisposed();
+        const guessedIndentation = guessIndentation(this._buffer, defaultTabSize, defaultInsertSpaces);
+        this.updateOptions({
+            insertSpaces: guessedIndentation.insertSpaces,
+            tabSize: guessedIndentation.tabSize,
+            indentSize: guessedIndentation.tabSize, // TODO@Alex: guess indentSize independent of tabSize
+        });
+    }
+    normalizeIndentation(str) {
+        this._assertNotDisposed();
+        return normalizeIndentation(str, this._options.indentSize, this._options.insertSpaces);
+    }
+    //#endregion
+    //#region Reading
+    getVersionId() {
+        this._assertNotDisposed();
+        return this._versionId;
+    }
+    mightContainRTL() {
+        return this._buffer.mightContainRTL();
+    }
+    mightContainUnusualLineTerminators() {
+        return this._buffer.mightContainUnusualLineTerminators();
+    }
+    removeUnusualLineTerminators(selections = null) {
+        const matches = this.findMatches(strings.UNUSUAL_LINE_TERMINATORS.source, false, true, false, null, false, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */);
+        this._buffer.resetMightContainUnusualLineTerminators();
+        this.pushEditOperations(selections, matches.map(m => ({ range: m.range, text: null })), () => null);
+    }
+    mightContainNonBasicASCII() {
+        return this._buffer.mightContainNonBasicASCII();
+    }
+    getAlternativeVersionId() {
+        this._assertNotDisposed();
+        return this._alternativeVersionId;
+    }
+    getInitialUndoRedoSnapshot() {
+        this._assertNotDisposed();
+        return this._initialUndoRedoSnapshot;
+    }
+    getOffsetAt(rawPosition) {
+        this._assertNotDisposed();
+        const position = this._validatePosition(rawPosition.lineNumber, rawPosition.column, 0 /* StringOffsetValidationType.Relaxed */);
+        return this._buffer.getOffsetAt(position.lineNumber, position.column);
+    }
+    getPositionAt(rawOffset) {
+        this._assertNotDisposed();
+        const offset = (Math.min(this._buffer.getLength(), Math.max(0, rawOffset)));
+        return this._buffer.getPositionAt(offset);
+    }
+    _increaseVersionId() {
+        this._versionId = this._versionId + 1;
+        this._alternativeVersionId = this._versionId;
+    }
+    _overwriteVersionId(versionId) {
+        this._versionId = versionId;
+    }
+    _overwriteAlternativeVersionId(newAlternativeVersionId) {
+        this._alternativeVersionId = newAlternativeVersionId;
+    }
+    _overwriteInitialUndoRedoSnapshot(newInitialUndoRedoSnapshot) {
+        this._initialUndoRedoSnapshot = newInitialUndoRedoSnapshot;
+    }
+    getValue(eol, preserveBOM = false) {
+        this._assertNotDisposed();
+        if (this.isTooLargeForHeapOperation()) {
+            throw new BugIndicatingError('Operation would exceed heap memory limits');
+        }
+        const fullModelRange = this.getFullModelRange();
+        const fullModelValue = this.getValueInRange(fullModelRange, eol);
+        if (preserveBOM) {
+            return this._buffer.getBOM() + fullModelValue;
+        }
+        return fullModelValue;
+    }
+    createSnapshot(preserveBOM = false) {
+        return new TextModelSnapshot(this._buffer.createSnapshot(preserveBOM));
+    }
+    getValueLength(eol, preserveBOM = false) {
+        this._assertNotDisposed();
+        const fullModelRange = this.getFullModelRange();
+        const fullModelValue = this.getValueLengthInRange(fullModelRange, eol);
+        if (preserveBOM) {
+            return this._buffer.getBOM().length + fullModelValue;
+        }
+        return fullModelValue;
+    }
+    getValueInRange(rawRange, eol = 0 /* model.EndOfLinePreference.TextDefined */) {
+        this._assertNotDisposed();
+        return this._buffer.getValueInRange(this.validateRange(rawRange), eol);
+    }
+    getValueLengthInRange(rawRange, eol = 0 /* model.EndOfLinePreference.TextDefined */) {
+        this._assertNotDisposed();
+        return this._buffer.getValueLengthInRange(this.validateRange(rawRange), eol);
+    }
+    getCharacterCountInRange(rawRange, eol = 0 /* model.EndOfLinePreference.TextDefined */) {
+        this._assertNotDisposed();
+        return this._buffer.getCharacterCountInRange(this.validateRange(rawRange), eol);
+    }
+    getLineCount() {
+        this._assertNotDisposed();
+        return this._buffer.getLineCount();
+    }
+    getLineContent(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineContent(lineNumber);
+    }
+    getLineLength(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineLength(lineNumber);
+    }
+    getLinesContent() {
+        this._assertNotDisposed();
+        if (this.isTooLargeForHeapOperation()) {
+            throw new BugIndicatingError('Operation would exceed heap memory limits');
+        }
+        return this._buffer.getLinesContent();
+    }
+    getEOL() {
+        this._assertNotDisposed();
+        return this._buffer.getEOL();
+    }
+    getEndOfLineSequence() {
+        this._assertNotDisposed();
+        return (this._buffer.getEOL() === '\n'
+            ? 0 /* model.EndOfLineSequence.LF */
+            : 1 /* model.EndOfLineSequence.CRLF */);
+    }
+    getLineMinColumn(lineNumber) {
+        this._assertNotDisposed();
+        return 1;
+    }
+    getLineMaxColumn(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineLength(lineNumber) + 1;
+    }
+    getLineFirstNonWhitespaceColumn(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineFirstNonWhitespaceColumn(lineNumber);
+    }
+    getLineLastNonWhitespaceColumn(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineLastNonWhitespaceColumn(lineNumber);
+    }
+    /**
+     * Validates `range` is within buffer bounds, but allows it to sit in between surrogate pairs, etc.
+     * Will try to not allocate if possible.
+     */
+    _validateRangeRelaxedNoAllocations(range) {
+        const linesCount = this._buffer.getLineCount();
+        const initialStartLineNumber = range.startLineNumber;
+        const initialStartColumn = range.startColumn;
+        let startLineNumber = Math.floor((typeof initialStartLineNumber === 'number' && !isNaN(initialStartLineNumber)) ? initialStartLineNumber : 1);
+        let startColumn = Math.floor((typeof initialStartColumn === 'number' && !isNaN(initialStartColumn)) ? initialStartColumn : 1);
+        if (startLineNumber < 1) {
+            startLineNumber = 1;
+            startColumn = 1;
+        }
+        else if (startLineNumber > linesCount) {
+            startLineNumber = linesCount;
+            startColumn = this.getLineMaxColumn(startLineNumber);
+        }
+        else {
+            if (startColumn <= 1) {
+                startColumn = 1;
+            }
+            else {
+                const maxColumn = this.getLineMaxColumn(startLineNumber);
+                if (startColumn >= maxColumn) {
+                    startColumn = maxColumn;
+                }
+            }
+        }
+        const initialEndLineNumber = range.endLineNumber;
+        const initialEndColumn = range.endColumn;
+        let endLineNumber = Math.floor((typeof initialEndLineNumber === 'number' && !isNaN(initialEndLineNumber)) ? initialEndLineNumber : 1);
+        let endColumn = Math.floor((typeof initialEndColumn === 'number' && !isNaN(initialEndColumn)) ? initialEndColumn : 1);
+        if (endLineNumber < 1) {
+            endLineNumber = 1;
+            endColumn = 1;
+        }
+        else if (endLineNumber > linesCount) {
+            endLineNumber = linesCount;
+            endColumn = this.getLineMaxColumn(endLineNumber);
+        }
+        else {
+            if (endColumn <= 1) {
+                endColumn = 1;
+            }
+            else {
+                const maxColumn = this.getLineMaxColumn(endLineNumber);
+                if (endColumn >= maxColumn) {
+                    endColumn = maxColumn;
+                }
+            }
+        }
+        if (initialStartLineNumber === startLineNumber
+            && initialStartColumn === startColumn
+            && initialEndLineNumber === endLineNumber
+            && initialEndColumn === endColumn
+            && range instanceof Range
+            && !(range instanceof Selection)) {
+            return range;
+        }
+        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+    }
+    _isValidPosition(lineNumber, column, validationType) {
+        if (typeof lineNumber !== 'number' || typeof column !== 'number') {
+            return false;
+        }
+        if (isNaN(lineNumber) || isNaN(column)) {
+            return false;
+        }
+        if (lineNumber < 1 || column < 1) {
+            return false;
+        }
+        if ((lineNumber | 0) !== lineNumber || (column | 0) !== column) {
+            return false;
+        }
+        const lineCount = this._buffer.getLineCount();
+        if (lineNumber > lineCount) {
+            return false;
+        }
+        if (column === 1) {
+            return true;
+        }
+        const maxColumn = this.getLineMaxColumn(lineNumber);
+        if (column > maxColumn) {
+            return false;
+        }
+        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {
+            // !!At this point, column > 1
+            const charCodeBefore = this._buffer.getLineCharCode(lineNumber, column - 2);
+            if (strings.isHighSurrogate(charCodeBefore)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _validatePosition(_lineNumber, _column, validationType) {
+        const lineNumber = Math.floor((typeof _lineNumber === 'number' && !isNaN(_lineNumber)) ? _lineNumber : 1);
+        const column = Math.floor((typeof _column === 'number' && !isNaN(_column)) ? _column : 1);
+        const lineCount = this._buffer.getLineCount();
+        if (lineNumber < 1) {
+            return new Position(1, 1);
+        }
+        if (lineNumber > lineCount) {
+            return new Position(lineCount, this.getLineMaxColumn(lineCount));
+        }
+        if (column <= 1) {
+            return new Position(lineNumber, 1);
+        }
+        const maxColumn = this.getLineMaxColumn(lineNumber);
+        if (column >= maxColumn) {
+            return new Position(lineNumber, maxColumn);
+        }
+        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {
+            // If the position would end up in the middle of a high-low surrogate pair,
+            // we move it to before the pair
+            // !!At this point, column > 1
+            const charCodeBefore = this._buffer.getLineCharCode(lineNumber, column - 2);
+            if (strings.isHighSurrogate(charCodeBefore)) {
+                return new Position(lineNumber, column - 1);
+            }
+        }
+        return new Position(lineNumber, column);
+    }
+    validatePosition(position) {
+        const validationType = 1 /* StringOffsetValidationType.SurrogatePairs */;
+        this._assertNotDisposed();
+        // Avoid object allocation and cover most likely case
+        if (position instanceof Position) {
+            if (this._isValidPosition(position.lineNumber, position.column, validationType)) {
+                return position;
+            }
+        }
+        return this._validatePosition(position.lineNumber, position.column, validationType);
+    }
+    _isValidRange(range, validationType) {
+        const startLineNumber = range.startLineNumber;
+        const startColumn = range.startColumn;
+        const endLineNumber = range.endLineNumber;
+        const endColumn = range.endColumn;
+        if (!this._isValidPosition(startLineNumber, startColumn, 0 /* StringOffsetValidationType.Relaxed */)) {
+            return false;
+        }
+        if (!this._isValidPosition(endLineNumber, endColumn, 0 /* StringOffsetValidationType.Relaxed */)) {
+            return false;
+        }
+        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {
+            const charCodeBeforeStart = (startColumn > 1 ? this._buffer.getLineCharCode(startLineNumber, startColumn - 2) : 0);
+            const charCodeBeforeEnd = (endColumn > 1 && endColumn <= this._buffer.getLineLength(endLineNumber) ? this._buffer.getLineCharCode(endLineNumber, endColumn - 2) : 0);
+            const startInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeStart);
+            const endInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeEnd);
+            if (!startInsideSurrogatePair && !endInsideSurrogatePair) {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    validateRange(_range) {
+        const validationType = 1 /* StringOffsetValidationType.SurrogatePairs */;
+        this._assertNotDisposed();
+        // Avoid object allocation and cover most likely case
+        if ((_range instanceof Range) && !(_range instanceof Selection)) {
+            if (this._isValidRange(_range, validationType)) {
+                return _range;
+            }
+        }
+        const start = this._validatePosition(_range.startLineNumber, _range.startColumn, 0 /* StringOffsetValidationType.Relaxed */);
+        const end = this._validatePosition(_range.endLineNumber, _range.endColumn, 0 /* StringOffsetValidationType.Relaxed */);
+        const startLineNumber = start.lineNumber;
+        const startColumn = start.column;
+        const endLineNumber = end.lineNumber;
+        const endColumn = end.column;
+        if (validationType === 1 /* StringOffsetValidationType.SurrogatePairs */) {
+            const charCodeBeforeStart = (startColumn > 1 ? this._buffer.getLineCharCode(startLineNumber, startColumn - 2) : 0);
+            const charCodeBeforeEnd = (endColumn > 1 && endColumn <= this._buffer.getLineLength(endLineNumber) ? this._buffer.getLineCharCode(endLineNumber, endColumn - 2) : 0);
+            const startInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeStart);
+            const endInsideSurrogatePair = strings.isHighSurrogate(charCodeBeforeEnd);
+            if (!startInsideSurrogatePair && !endInsideSurrogatePair) {
+                return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+            }
+            if (startLineNumber === endLineNumber && startColumn === endColumn) {
+                // do not expand a collapsed range, simply move it to a valid location
+                return new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn - 1);
+            }
+            if (startInsideSurrogatePair && endInsideSurrogatePair) {
+                // expand range at both ends
+                return new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn + 1);
+            }
+            if (startInsideSurrogatePair) {
+                // only expand range at the start
+                return new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn);
+            }
+            // only expand range at the end
+            return new Range(startLineNumber, startColumn, endLineNumber, endColumn + 1);
+        }
+        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
+    }
+    modifyPosition(rawPosition, offset) {
+        this._assertNotDisposed();
+        const candidate = this.getOffsetAt(rawPosition) + offset;
+        return this.getPositionAt(Math.min(this._buffer.getLength(), Math.max(0, candidate)));
+    }
+    getFullModelRange() {
+        this._assertNotDisposed();
+        const lineCount = this.getLineCount();
+        return new Range(1, 1, lineCount, this.getLineMaxColumn(lineCount));
+    }
+    findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount) {
+        return this._buffer.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);
+    }
+    findMatches(searchString, rawSearchScope, isRegex, matchCase, wordSeparators, captureMatches, limitResultCount = LIMIT_FIND_COUNT) {
+        this._assertNotDisposed();
+        let searchRanges = null;
+        if (rawSearchScope !== null) {
+            if (!Array.isArray(rawSearchScope)) {
+                rawSearchScope = [rawSearchScope];
+            }
+            if (rawSearchScope.every((searchScope) => Range.isIRange(searchScope))) {
+                searchRanges = rawSearchScope.map((searchScope) => this.validateRange(searchScope));
+            }
+        }
+        if (searchRanges === null) {
+            searchRanges = [this.getFullModelRange()];
+        }
+        searchRanges = searchRanges.sort((d1, d2) => d1.startLineNumber - d2.startLineNumber || d1.startColumn - d2.startColumn);
+        const uniqueSearchRanges = [];
+        uniqueSearchRanges.push(searchRanges.reduce((prev, curr) => {
+            if (Range.areIntersecting(prev, curr)) {
+                return prev.plusRange(curr);
+            }
+            uniqueSearchRanges.push(prev);
+            return curr;
+        }));
+        let matchMapper;
+        if (!isRegex && searchString.indexOf('\n') < 0) {
+            // not regex, not multi line
+            const searchParams = new SearchParams(searchString, isRegex, matchCase, wordSeparators);
+            const searchData = searchParams.parseSearchRequest();
+            if (!searchData) {
+                return [];
+            }
+            matchMapper = (searchRange) => this.findMatchesLineByLine(searchRange, searchData, captureMatches, limitResultCount);
+        }
+        else {
+            matchMapper = (searchRange) => TextModelSearch.findMatches(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchRange, captureMatches, limitResultCount);
+        }
+        return uniqueSearchRanges.map(matchMapper).reduce((arr, matches) => arr.concat(matches), []);
+    }
+    findNextMatch(searchString, rawSearchStart, isRegex, matchCase, wordSeparators, captureMatches) {
+        this._assertNotDisposed();
+        const searchStart = this.validatePosition(rawSearchStart);
+        if (!isRegex && searchString.indexOf('\n') < 0) {
+            const searchParams = new SearchParams(searchString, isRegex, matchCase, wordSeparators);
+            const searchData = searchParams.parseSearchRequest();
+            if (!searchData) {
+                return null;
+            }
+            const lineCount = this.getLineCount();
+            let searchRange = new Range(searchStart.lineNumber, searchStart.column, lineCount, this.getLineMaxColumn(lineCount));
+            let ret = this.findMatchesLineByLine(searchRange, searchData, captureMatches, 1);
+            TextModelSearch.findNextMatch(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchStart, captureMatches);
+            if (ret.length > 0) {
+                return ret[0];
+            }
+            searchRange = new Range(1, 1, searchStart.lineNumber, this.getLineMaxColumn(searchStart.lineNumber));
+            ret = this.findMatchesLineByLine(searchRange, searchData, captureMatches, 1);
+            if (ret.length > 0) {
+                return ret[0];
+            }
+            return null;
+        }
+        return TextModelSearch.findNextMatch(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchStart, captureMatches);
+    }
+    findPreviousMatch(searchString, rawSearchStart, isRegex, matchCase, wordSeparators, captureMatches) {
+        this._assertNotDisposed();
+        const searchStart = this.validatePosition(rawSearchStart);
+        return TextModelSearch.findPreviousMatch(this, new SearchParams(searchString, isRegex, matchCase, wordSeparators), searchStart, captureMatches);
+    }
+    //#endregion
+    //#region Editing
+    pushStackElement() {
+        this._commandManager.pushStackElement();
+    }
+    popStackElement() {
+        this._commandManager.popStackElement();
+    }
+    pushEOL(eol) {
+        const currentEOL = (this.getEOL() === '\n' ? 0 /* model.EndOfLineSequence.LF */ : 1 /* model.EndOfLineSequence.CRLF */);
+        if (currentEOL === eol) {
+            return;
+        }
+        try {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._eventEmitter.beginDeferredEmit();
+            if (this._initialUndoRedoSnapshot === null) {
+                this._initialUndoRedoSnapshot = this._undoRedoService.createSnapshot(this.uri);
+            }
+            this._commandManager.pushEOL(eol);
+        }
+        finally {
+            this._eventEmitter.endDeferredEmit();
+            this._onDidChangeDecorations.endDeferredEmit();
+        }
+    }
+    _validateEditOperation(rawOperation) {
+        if (rawOperation instanceof model.ValidAnnotatedEditOperation) {
+            return rawOperation;
+        }
+        return new model.ValidAnnotatedEditOperation(rawOperation.identifier || null, this.validateRange(rawOperation.range), rawOperation.text, rawOperation.forceMoveMarkers || false, rawOperation.isAutoWhitespaceEdit || false, rawOperation._isTracked || false);
+    }
+    _validateEditOperations(rawOperations) {
+        const result = [];
+        for (let i = 0, len = rawOperations.length; i < len; i++) {
+            result[i] = this._validateEditOperation(rawOperations[i]);
+        }
+        return result;
+    }
+    pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group) {
+        try {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._eventEmitter.beginDeferredEmit();
+            return this._pushEditOperations(beforeCursorState, this._validateEditOperations(editOperations), cursorStateComputer, group);
+        }
+        finally {
+            this._eventEmitter.endDeferredEmit();
+            this._onDidChangeDecorations.endDeferredEmit();
+        }
+    }
+    _pushEditOperations(beforeCursorState, editOperations, cursorStateComputer, group) {
+        if (this._options.trimAutoWhitespace && this._trimAutoWhitespaceLines) {
+            // Go through each saved line number and insert a trim whitespace edit
+            // if it is safe to do so (no conflicts with other edits).
+            const incomingEdits = editOperations.map((op) => {
+                return {
+                    range: this.validateRange(op.range),
+                    text: op.text
+                };
+            });
+            // Sometimes, auto-formatters change ranges automatically which can cause undesired auto whitespace trimming near the cursor
+            // We'll use the following heuristic: if the edits occur near the cursor, then it's ok to trim auto whitespace
+            let editsAreNearCursors = true;
+            if (beforeCursorState) {
+                for (let i = 0, len = beforeCursorState.length; i < len; i++) {
+                    const sel = beforeCursorState[i];
+                    let foundEditNearSel = false;
+                    for (let j = 0, lenJ = incomingEdits.length; j < lenJ; j++) {
+                        const editRange = incomingEdits[j].range;
+                        const selIsAbove = editRange.startLineNumber > sel.endLineNumber;
+                        const selIsBelow = sel.startLineNumber > editRange.endLineNumber;
+                        if (!selIsAbove && !selIsBelow) {
+                            foundEditNearSel = true;
+                            break;
+                        }
+                    }
+                    if (!foundEditNearSel) {
+                        editsAreNearCursors = false;
+                        break;
+                    }
+                }
+            }
+            if (editsAreNearCursors) {
+                for (let i = 0, len = this._trimAutoWhitespaceLines.length; i < len; i++) {
+                    const trimLineNumber = this._trimAutoWhitespaceLines[i];
+                    const maxLineColumn = this.getLineMaxColumn(trimLineNumber);
+                    let allowTrimLine = true;
+                    for (let j = 0, lenJ = incomingEdits.length; j < lenJ; j++) {
+                        const editRange = incomingEdits[j].range;
+                        const editText = incomingEdits[j].text;
+                        if (trimLineNumber < editRange.startLineNumber || trimLineNumber > editRange.endLineNumber) {
+                            // `trimLine` is completely outside this edit
+                            continue;
+                        }
+                        // At this point:
+                        //   editRange.startLineNumber <= trimLine <= editRange.endLineNumber
+                        if (trimLineNumber === editRange.startLineNumber && editRange.startColumn === maxLineColumn
+                            && editRange.isEmpty() && editText && editText.length > 0 && editText.charAt(0) === '\n') {
+                            // This edit inserts a new line (and maybe other text) after `trimLine`
+                            continue;
+                        }
+                        if (trimLineNumber === editRange.startLineNumber && editRange.startColumn === 1
+                            && editRange.isEmpty() && editText && editText.length > 0 && editText.charAt(editText.length - 1) === '\n') {
+                            // This edit inserts a new line (and maybe other text) before `trimLine`
+                            continue;
+                        }
+                        // Looks like we can't trim this line as it would interfere with an incoming edit
+                        allowTrimLine = false;
+                        break;
+                    }
+                    if (allowTrimLine) {
+                        const trimRange = new Range(trimLineNumber, 1, trimLineNumber, maxLineColumn);
+                        editOperations.push(new model.ValidAnnotatedEditOperation(null, trimRange, null, false, false, false));
+                    }
+                }
+            }
+            this._trimAutoWhitespaceLines = null;
+        }
+        if (this._initialUndoRedoSnapshot === null) {
+            this._initialUndoRedoSnapshot = this._undoRedoService.createSnapshot(this.uri);
+        }
+        return this._commandManager.pushEditOperation(beforeCursorState, editOperations, cursorStateComputer, group);
+    }
+    _applyUndo(changes, eol, resultingAlternativeVersionId, resultingSelection) {
+        const edits = changes.map((change) => {
+            const rangeStart = this.getPositionAt(change.newPosition);
+            const rangeEnd = this.getPositionAt(change.newEnd);
+            return {
+                range: new Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column),
+                text: change.oldText
+            };
+        });
+        this._applyUndoRedoEdits(edits, eol, true, false, resultingAlternativeVersionId, resultingSelection);
+    }
+    _applyRedo(changes, eol, resultingAlternativeVersionId, resultingSelection) {
+        const edits = changes.map((change) => {
+            const rangeStart = this.getPositionAt(change.oldPosition);
+            const rangeEnd = this.getPositionAt(change.oldEnd);
+            return {
+                range: new Range(rangeStart.lineNumber, rangeStart.column, rangeEnd.lineNumber, rangeEnd.column),
+                text: change.newText
+            };
+        });
+        this._applyUndoRedoEdits(edits, eol, false, true, resultingAlternativeVersionId, resultingSelection);
+    }
+    _applyUndoRedoEdits(edits, eol, isUndoing, isRedoing, resultingAlternativeVersionId, resultingSelection) {
+        try {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._eventEmitter.beginDeferredEmit();
+            this._isUndoing = isUndoing;
+            this._isRedoing = isRedoing;
+            this.applyEdits(edits, false);
+            this.setEOL(eol);
+            this._overwriteAlternativeVersionId(resultingAlternativeVersionId);
+        }
+        finally {
+            this._isUndoing = false;
+            this._isRedoing = false;
+            this._eventEmitter.endDeferredEmit(resultingSelection);
+            this._onDidChangeDecorations.endDeferredEmit();
+        }
+    }
+    applyEdits(rawOperations, computeUndoEdits = false) {
+        try {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            this._eventEmitter.beginDeferredEmit();
+            const operations = this._validateEditOperations(rawOperations);
+            return this._doApplyEdits(operations, computeUndoEdits);
+        }
+        finally {
+            this._eventEmitter.endDeferredEmit();
+            this._onDidChangeDecorations.endDeferredEmit();
+        }
+    }
+    _doApplyEdits(rawOperations, computeUndoEdits) {
+        const oldLineCount = this._buffer.getLineCount();
+        const result = this._buffer.applyEdits(rawOperations, this._options.trimAutoWhitespace, computeUndoEdits);
+        const newLineCount = this._buffer.getLineCount();
+        const contentChanges = result.changes;
+        this._trimAutoWhitespaceLines = result.trimAutoWhitespaceLineNumbers;
+        if (contentChanges.length !== 0) {
+            // We do a first pass to update decorations
+            // because we want to read decorations in the second pass
+            // where we will emit content change events
+            // and we want to read the final decorations
+            for (let i = 0, len = contentChanges.length; i < len; i++) {
+                const change = contentChanges[i];
+                this._decorationsTree.acceptReplace(change.rangeOffset, change.rangeLength, change.text.length, change.forceMoveMarkers);
+            }
+            const rawContentChanges = [];
+            this._increaseVersionId();
+            let lineCount = oldLineCount;
+            for (let i = 0, len = contentChanges.length; i < len; i++) {
+                const change = contentChanges[i];
+                const [eolCount] = countEOL(change.text);
+                this._onDidChangeDecorations.fire();
+                const startLineNumber = change.range.startLineNumber;
+                const endLineNumber = change.range.endLineNumber;
+                const deletingLinesCnt = endLineNumber - startLineNumber;
+                const insertingLinesCnt = eolCount;
+                const editingLinesCnt = Math.min(deletingLinesCnt, insertingLinesCnt);
+                const changeLineCountDelta = (insertingLinesCnt - deletingLinesCnt);
+                const currentEditStartLineNumber = newLineCount - lineCount - changeLineCountDelta + startLineNumber;
+                const firstEditLineNumber = currentEditStartLineNumber;
+                const lastInsertedLineNumber = currentEditStartLineNumber + insertingLinesCnt;
+                const decorationsWithInjectedTextInEditedRange = this._decorationsTree.getInjectedTextInInterval(this, this.getOffsetAt(new Position(firstEditLineNumber, 1)), this.getOffsetAt(new Position(lastInsertedLineNumber, this.getLineMaxColumn(lastInsertedLineNumber))), 0);
+                const injectedTextInEditedRange = LineInjectedText.fromDecorations(decorationsWithInjectedTextInEditedRange);
+                const injectedTextInEditedRangeQueue = new ArrayQueue(injectedTextInEditedRange);
+                for (let j = editingLinesCnt; j >= 0; j--) {
+                    const editLineNumber = startLineNumber + j;
+                    const currentEditLineNumber = currentEditStartLineNumber + j;
+                    injectedTextInEditedRangeQueue.takeFromEndWhile(r => r.lineNumber > currentEditLineNumber);
+                    const decorationsInCurrentLine = injectedTextInEditedRangeQueue.takeFromEndWhile(r => r.lineNumber === currentEditLineNumber);
+                    rawContentChanges.push(new ModelRawLineChanged(editLineNumber, this.getLineContent(currentEditLineNumber), decorationsInCurrentLine));
+                }
+                if (editingLinesCnt < deletingLinesCnt) {
+                    // Must delete some lines
+                    const spliceStartLineNumber = startLineNumber + editingLinesCnt;
+                    rawContentChanges.push(new ModelRawLinesDeleted(spliceStartLineNumber + 1, endLineNumber));
+                }
+                if (editingLinesCnt < insertingLinesCnt) {
+                    const injectedTextInEditedRangeQueue = new ArrayQueue(injectedTextInEditedRange);
+                    // Must insert some lines
+                    const spliceLineNumber = startLineNumber + editingLinesCnt;
+                    const cnt = insertingLinesCnt - editingLinesCnt;
+                    const fromLineNumber = newLineCount - lineCount - cnt + spliceLineNumber + 1;
+                    const injectedTexts = [];
+                    const newLines = [];
+                    for (let i = 0; i < cnt; i++) {
+                        const lineNumber = fromLineNumber + i;
+                        newLines[i] = this.getLineContent(lineNumber);
+                        injectedTextInEditedRangeQueue.takeWhile(r => r.lineNumber < lineNumber);
+                        injectedTexts[i] = injectedTextInEditedRangeQueue.takeWhile(r => r.lineNumber === lineNumber);
+                    }
+                    rawContentChanges.push(new ModelRawLinesInserted(spliceLineNumber + 1, startLineNumber + insertingLinesCnt, newLines, injectedTexts));
+                }
+                lineCount += changeLineCountDelta;
+            }
+            this._emitContentChangedEvent(new ModelRawContentChangedEvent(rawContentChanges, this.getVersionId(), this._isUndoing, this._isRedoing), {
+                changes: contentChanges,
+                eol: this._buffer.getEOL(),
+                isEolChange: false,
+                versionId: this.getVersionId(),
+                isUndoing: this._isUndoing,
+                isRedoing: this._isRedoing,
+                isFlush: false
+            });
+        }
+        return (result.reverseEdits === null ? undefined : result.reverseEdits);
+    }
+    undo() {
+        return this._undoRedoService.undo(this.uri);
+    }
+    canUndo() {
+        return this._undoRedoService.canUndo(this.uri);
+    }
+    redo() {
+        return this._undoRedoService.redo(this.uri);
+    }
+    canRedo() {
+        return this._undoRedoService.canRedo(this.uri);
+    }
+    //#endregion
+    //#region Decorations
+    handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines) {
+        // This is called before the decoration changed event is fired.
+        if (affectedInjectedTextLines === null || affectedInjectedTextLines.size === 0) {
+            return;
+        }
+        const affectedLines = Array.from(affectedInjectedTextLines);
+        const lineChangeEvents = affectedLines.map(lineNumber => new ModelRawLineChanged(lineNumber, this.getLineContent(lineNumber), this._getInjectedTextInLine(lineNumber)));
+        this._onDidChangeInjectedText.fire(new ModelInjectedTextChangedEvent(lineChangeEvents));
+    }
+    changeDecorations(callback, ownerId = 0) {
+        this._assertNotDisposed();
+        try {
+            this._onDidChangeDecorations.beginDeferredEmit();
+            return this._changeDecorations(ownerId, callback);
+        }
+        finally {
+            this._onDidChangeDecorations.endDeferredEmit();
+        }
+    }
+    _changeDecorations(ownerId, callback) {
+        const changeAccessor = {
+            addDecoration: (range, options) => {
+                return this._deltaDecorationsImpl(ownerId, [], [{ range: range, options: options }])[0];
+            },
+            changeDecoration: (id, newRange) => {
+                this._changeDecorationImpl(id, newRange);
+            },
+            changeDecorationOptions: (id, options) => {
+                this._changeDecorationOptionsImpl(id, _normalizeOptions(options));
+            },
+            removeDecoration: (id) => {
+                this._deltaDecorationsImpl(ownerId, [id], []);
+            },
+            deltaDecorations: (oldDecorations, newDecorations) => {
+                if (oldDecorations.length === 0 && newDecorations.length === 0) {
+                    // nothing to do
+                    return [];
+                }
+                return this._deltaDecorationsImpl(ownerId, oldDecorations, newDecorations);
+            }
+        };
+        let result = null;
+        try {
+            result = callback(changeAccessor);
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+        // Invalidate change accessor
+        changeAccessor.addDecoration = invalidFunc;
+        changeAccessor.changeDecoration = invalidFunc;
+        changeAccessor.changeDecorationOptions = invalidFunc;
+        changeAccessor.removeDecoration = invalidFunc;
+        changeAccessor.deltaDecorations = invalidFunc;
+        return result;
+    }
+    deltaDecorations(oldDecorations, newDecorations, ownerId = 0) {
+        this._assertNotDisposed();
+        if (!oldDecorations) {
+            oldDecorations = [];
+        }
+        if (oldDecorations.length === 0 && newDecorations.length === 0) {
+            // nothing to do
+            return [];
+        }
+        try {
+            this._deltaDecorationCallCnt++;
+            if (this._deltaDecorationCallCnt > 1) {
+                console.warn(`Invoking deltaDecorations recursively could lead to leaking decorations.`);
+                onUnexpectedError(new Error(`Invoking deltaDecorations recursively could lead to leaking decorations.`));
+            }
+            this._onDidChangeDecorations.beginDeferredEmit();
+            return this._deltaDecorationsImpl(ownerId, oldDecorations, newDecorations);
+        }
+        finally {
+            this._onDidChangeDecorations.endDeferredEmit();
+            this._deltaDecorationCallCnt--;
+        }
+    }
+    _getTrackedRange(id) {
+        return this.getDecorationRange(id);
+    }
+    _setTrackedRange(id, newRange, newStickiness) {
+        const node = (id ? this._decorations[id] : null);
+        if (!node) {
+            if (!newRange) {
+                // node doesn't exist, the request is to delete => nothing to do
+                return null;
+            }
+            // node doesn't exist, the request is to set => add the tracked range
+            return this._deltaDecorationsImpl(0, [], [{ range: newRange, options: TRACKED_RANGE_OPTIONS[newStickiness] }], true)[0];
+        }
+        if (!newRange) {
+            // node exists, the request is to delete => delete node
+            this._decorationsTree.delete(node);
+            delete this._decorations[node.id];
+            return null;
+        }
+        // node exists, the request is to set => change the tracked range and its options
+        const range = this._validateRangeRelaxedNoAllocations(newRange);
+        const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);
+        const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);
+        this._decorationsTree.delete(node);
+        node.reset(this.getVersionId(), startOffset, endOffset, range);
+        node.setOptions(TRACKED_RANGE_OPTIONS[newStickiness]);
+        this._decorationsTree.insert(node);
+        return node.id;
+    }
+    removeAllDecorationsWithOwnerId(ownerId) {
+        if (this._isDisposed) {
+            return;
+        }
+        const nodes = this._decorationsTree.collectNodesFromOwner(ownerId);
+        for (let i = 0, len = nodes.length; i < len; i++) {
+            const node = nodes[i];
+            this._decorationsTree.delete(node);
+            delete this._decorations[node.id];
+        }
+    }
+    getDecorationOptions(decorationId) {
+        const node = this._decorations[decorationId];
+        if (!node) {
+            return null;
+        }
+        return node.options;
+    }
+    getDecorationRange(decorationId) {
+        const node = this._decorations[decorationId];
+        if (!node) {
+            return null;
+        }
+        return this._decorationsTree.getNodeRange(this, node);
+    }
+    getLineDecorations(lineNumber, ownerId = 0, filterOutValidation = false) {
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            return [];
+        }
+        return this.getLinesDecorations(lineNumber, lineNumber, ownerId, filterOutValidation);
+    }
+    getLinesDecorations(_startLineNumber, _endLineNumber, ownerId = 0, filterOutValidation = false, onlyMarginDecorations = false) {
+        const lineCount = this.getLineCount();
+        const startLineNumber = Math.min(lineCount, Math.max(1, _startLineNumber));
+        const endLineNumber = Math.min(lineCount, Math.max(1, _endLineNumber));
+        const endColumn = this.getLineMaxColumn(endLineNumber);
+        const range = new Range(startLineNumber, 1, endLineNumber, endColumn);
+        const decorations = this._getDecorationsInRange(range, ownerId, filterOutValidation, onlyMarginDecorations);
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
+        return decorations;
+    }
+    getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, onlyMinimapDecorations = false, onlyMarginDecorations = false) {
+        const validatedRange = this.validateRange(range);
+        const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMarginDecorations);
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
+        return decorations;
+    }
+    getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false) {
+        return this._decorationsTree.getAll(this, ownerId, filterOutValidation, true, false);
+    }
+    getInjectedTextDecorations(ownerId = 0) {
+        return this._decorationsTree.getAllInjectedText(this, ownerId);
+    }
+    _getInjectedTextInLine(lineNumber) {
+        const startOffset = this._buffer.getOffsetAt(lineNumber, 1);
+        const endOffset = startOffset + this._buffer.getLineLength(lineNumber);
+        const result = this._decorationsTree.getInjectedTextInInterval(this, startOffset, endOffset, 0);
+        return LineInjectedText.fromDecorations(result).filter(t => t.lineNumber === lineNumber);
+    }
+    getAllDecorations(ownerId = 0, filterOutValidation = false) {
+        let result = this._decorationsTree.getAll(this, ownerId, filterOutValidation, false, false);
+        result = result.concat(this._decorationProvider.getAllDecorations(ownerId, filterOutValidation));
+        return result;
+    }
+    getAllMarginDecorations(ownerId = 0) {
+        return this._decorationsTree.getAll(this, ownerId, false, false, true);
+    }
+    _getDecorationsInRange(filterRange, filterOwnerId, filterOutValidation, onlyMarginDecorations) {
+        const startOffset = this._buffer.getOffsetAt(filterRange.startLineNumber, filterRange.startColumn);
+        const endOffset = this._buffer.getOffsetAt(filterRange.endLineNumber, filterRange.endColumn);
+        return this._decorationsTree.getAllInInterval(this, startOffset, endOffset, filterOwnerId, filterOutValidation, onlyMarginDecorations);
+    }
+    getRangeAt(start, end) {
+        return this._buffer.getRangeAt(start, end - start);
+    }
+    _changeDecorationImpl(decorationId, _range) {
+        const node = this._decorations[decorationId];
+        if (!node) {
+            return;
+        }
+        if (node.options.after) {
+            const oldRange = this.getDecorationRange(decorationId);
+            this._onDidChangeDecorations.recordLineAffectedByInjectedText(oldRange.endLineNumber);
+        }
+        if (node.options.before) {
+            const oldRange = this.getDecorationRange(decorationId);
+            this._onDidChangeDecorations.recordLineAffectedByInjectedText(oldRange.startLineNumber);
+        }
+        const range = this._validateRangeRelaxedNoAllocations(_range);
+        const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);
+        const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);
+        this._decorationsTree.delete(node);
+        node.reset(this.getVersionId(), startOffset, endOffset, range);
+        this._decorationsTree.insert(node);
+        this._onDidChangeDecorations.checkAffectedAndFire(node.options);
+        if (node.options.after) {
+            this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.endLineNumber);
+        }
+        if (node.options.before) {
+            this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.startLineNumber);
+        }
+    }
+    _changeDecorationOptionsImpl(decorationId, options) {
+        const node = this._decorations[decorationId];
+        if (!node) {
+            return;
+        }
+        const nodeWasInOverviewRuler = (node.options.overviewRuler && node.options.overviewRuler.color ? true : false);
+        const nodeIsInOverviewRuler = (options.overviewRuler && options.overviewRuler.color ? true : false);
+        this._onDidChangeDecorations.checkAffectedAndFire(node.options);
+        this._onDidChangeDecorations.checkAffectedAndFire(options);
+        if (node.options.after || options.after) {
+            const nodeRange = this._decorationsTree.getNodeRange(this, node);
+            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.endLineNumber);
+        }
+        if (node.options.before || options.before) {
+            const nodeRange = this._decorationsTree.getNodeRange(this, node);
+            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.startLineNumber);
+        }
+        const movedInOverviewRuler = nodeWasInOverviewRuler !== nodeIsInOverviewRuler;
+        const changedWhetherInjectedText = isOptionsInjectedText(options) !== isNodeInjectedText(node);
+        if (movedInOverviewRuler || changedWhetherInjectedText) {
+            this._decorationsTree.delete(node);
+            node.setOptions(options);
+            this._decorationsTree.insert(node);
+        }
+        else {
+            node.setOptions(options);
+        }
+    }
+    _deltaDecorationsImpl(ownerId, oldDecorationsIds, newDecorations, suppressEvents = false) {
+        const versionId = this.getVersionId();
+        const oldDecorationsLen = oldDecorationsIds.length;
+        let oldDecorationIndex = 0;
+        const newDecorationsLen = newDecorations.length;
+        let newDecorationIndex = 0;
+        this._onDidChangeDecorations.beginDeferredEmit();
+        try {
+            const result = new Array(newDecorationsLen);
+            while (oldDecorationIndex < oldDecorationsLen || newDecorationIndex < newDecorationsLen) {
+                let node = null;
+                if (oldDecorationIndex < oldDecorationsLen) {
+                    // (1) get ourselves an old node
+                    do {
+                        node = this._decorations[oldDecorationsIds[oldDecorationIndex++]];
+                    } while (!node && oldDecorationIndex < oldDecorationsLen);
+                    // (2) remove the node from the tree (if it exists)
+                    if (node) {
+                        if (node.options.after) {
+                            const nodeRange = this._decorationsTree.getNodeRange(this, node);
+                            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.endLineNumber);
+                        }
+                        if (node.options.before) {
+                            const nodeRange = this._decorationsTree.getNodeRange(this, node);
+                            this._onDidChangeDecorations.recordLineAffectedByInjectedText(nodeRange.startLineNumber);
+                        }
+                        this._decorationsTree.delete(node);
+                        if (!suppressEvents) {
+                            this._onDidChangeDecorations.checkAffectedAndFire(node.options);
+                        }
+                    }
+                }
+                if (newDecorationIndex < newDecorationsLen) {
+                    // (3) create a new node if necessary
+                    if (!node) {
+                        const internalDecorationId = (++this._lastDecorationId);
+                        const decorationId = `${this._instanceId};${internalDecorationId}`;
+                        node = new IntervalNode(decorationId, 0, 0);
+                        this._decorations[decorationId] = node;
+                    }
+                    // (4) initialize node
+                    const newDecoration = newDecorations[newDecorationIndex];
+                    const range = this._validateRangeRelaxedNoAllocations(newDecoration.range);
+                    const options = _normalizeOptions(newDecoration.options);
+                    const startOffset = this._buffer.getOffsetAt(range.startLineNumber, range.startColumn);
+                    const endOffset = this._buffer.getOffsetAt(range.endLineNumber, range.endColumn);
+                    node.ownerId = ownerId;
+                    node.reset(versionId, startOffset, endOffset, range);
+                    node.setOptions(options);
+                    if (node.options.after) {
+                        this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.endLineNumber);
+                    }
+                    if (node.options.before) {
+                        this._onDidChangeDecorations.recordLineAffectedByInjectedText(range.startLineNumber);
+                    }
+                    if (!suppressEvents) {
+                        this._onDidChangeDecorations.checkAffectedAndFire(options);
+                    }
+                    this._decorationsTree.insert(node);
+                    result[newDecorationIndex] = node.id;
+                    newDecorationIndex++;
+                }
+                else {
+                    if (node) {
+                        delete this._decorations[node.id];
+                    }
+                }
+            }
+            return result;
+        }
+        finally {
+            this._onDidChangeDecorations.endDeferredEmit();
+        }
+    }
+    //#endregion
+    //#region Tokenization
+    // TODO move them to the tokenization part.
+    getLanguageId() {
+        return this.tokenization.getLanguageId();
+    }
+    setLanguage(languageIdOrSelection, source) {
+        if (typeof languageIdOrSelection === 'string') {
+            this._languageSelectionListener.clear();
+            this._setLanguage(languageIdOrSelection, source);
+        }
+        else {
+            this._languageSelectionListener.value = languageIdOrSelection.onDidChange(() => this._setLanguage(languageIdOrSelection.languageId, source));
+            this._setLanguage(languageIdOrSelection.languageId, source);
+        }
+    }
+    _setLanguage(languageId, source) {
+        this.tokenization.setLanguageId(languageId, source);
+        this._languageService.requestRichLanguageFeatures(languageId);
+    }
+    getLanguageIdAtPosition(lineNumber, column) {
+        return this.tokenization.getLanguageIdAtPosition(lineNumber, column);
+    }
+    getWordAtPosition(position) {
+        return this._tokenizationTextModelPart.getWordAtPosition(position);
+    }
+    getWordUntilPosition(position) {
+        return this._tokenizationTextModelPart.getWordUntilPosition(position);
+    }
+    //#endregion
+    normalizePosition(position, affinity) {
+        return position;
+    }
+    /**
+     * Gets the column at which indentation stops at a given line.
+     * @internal
+    */
+    getLineIndentColumn(lineNumber) {
+        // Columns start with 1.
+        return indentOfLine(this.getLineContent(lineNumber)) + 1;
+    }
+};
+TextModel = TextModel_1 = __decorate([
+    __param(4, IUndoRedoService),
+    __param(5, ILanguageService),
+    __param(6, ILanguageConfigurationService),
+    __param(7, IInstantiationService)
+], TextModel);
+export { TextModel };
+export function indentOfLine(line) {
+    let indent = 0;
+    for (const c of line) {
+        if (c === ' ' || c === '\t') {
+            indent++;
+        }
+        else {
+            break;
+        }
+    }
+    return indent;
+}
+//#region Decorations
+function isNodeInOverviewRuler(node) {
+    return (node.options.overviewRuler && node.options.overviewRuler.color ? true : false);
+}
+function isOptionsInjectedText(options) {
+    return !!options.after || !!options.before;
+}
+function isNodeInjectedText(node) {
+    return !!node.options.after || !!node.options.before;
+}
+class DecorationsTrees {
+    constructor() {
+        this._decorationsTree0 = new IntervalTree();
+        this._decorationsTree1 = new IntervalTree();
+        this._injectedTextDecorationsTree = new IntervalTree();
+    }
+    ensureAllNodesHaveRanges(host) {
+        this.getAll(host, 0, false, false, false);
+    }
+    _ensureNodesHaveRanges(host, nodes) {
+        for (const node of nodes) {
+            if (node.range === null) {
+                node.range = host.getRangeAt(node.cachedAbsoluteStart, node.cachedAbsoluteEnd);
+            }
+        }
+        return nodes;
+    }
+    getAllInInterval(host, start, end, filterOwnerId, filterOutValidation, onlyMarginDecorations) {
+        const versionId = host.getVersionId();
+        const result = this._intervalSearch(start, end, filterOwnerId, filterOutValidation, versionId, onlyMarginDecorations);
+        return this._ensureNodesHaveRanges(host, result);
+    }
+    _intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations) {
+        const r0 = this._decorationsTree0.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+        const r1 = this._decorationsTree1.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+        const r2 = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+        return r0.concat(r1).concat(r2);
+    }
+    getInjectedTextInInterval(host, start, end, filterOwnerId) {
+        const versionId = host.getVersionId();
+        const result = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, false, versionId, false);
+        return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());
+    }
+    getAllInjectedText(host, filterOwnerId) {
+        const versionId = host.getVersionId();
+        const result = this._injectedTextDecorationsTree.search(filterOwnerId, false, versionId, false);
+        return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());
+    }
+    getAll(host, filterOwnerId, filterOutValidation, overviewRulerOnly, onlyMarginDecorations) {
+        const versionId = host.getVersionId();
+        const result = this._search(filterOwnerId, filterOutValidation, overviewRulerOnly, versionId, onlyMarginDecorations);
+        return this._ensureNodesHaveRanges(host, result);
+    }
+    _search(filterOwnerId, filterOutValidation, overviewRulerOnly, cachedVersionId, onlyMarginDecorations) {
+        if (overviewRulerOnly) {
+            return this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+        }
+        else {
+            const r0 = this._decorationsTree0.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+            const r1 = this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+            const r2 = this._injectedTextDecorationsTree.search(filterOwnerId, filterOutValidation, cachedVersionId, onlyMarginDecorations);
+            return r0.concat(r1).concat(r2);
+        }
+    }
+    collectNodesFromOwner(ownerId) {
+        const r0 = this._decorationsTree0.collectNodesFromOwner(ownerId);
+        const r1 = this._decorationsTree1.collectNodesFromOwner(ownerId);
+        const r2 = this._injectedTextDecorationsTree.collectNodesFromOwner(ownerId);
+        return r0.concat(r1).concat(r2);
+    }
+    collectNodesPostOrder() {
+        const r0 = this._decorationsTree0.collectNodesPostOrder();
+        const r1 = this._decorationsTree1.collectNodesPostOrder();
+        const r2 = this._injectedTextDecorationsTree.collectNodesPostOrder();
+        return r0.concat(r1).concat(r2);
+    }
+    insert(node) {
+        if (isNodeInjectedText(node)) {
+            this._injectedTextDecorationsTree.insert(node);
+        }
+        else if (isNodeInOverviewRuler(node)) {
+            this._decorationsTree1.insert(node);
+        }
+        else {
+            this._decorationsTree0.insert(node);
+        }
+    }
+    delete(node) {
+        if (isNodeInjectedText(node)) {
+            this._injectedTextDecorationsTree.delete(node);
+        }
+        else if (isNodeInOverviewRuler(node)) {
+            this._decorationsTree1.delete(node);
+        }
+        else {
+            this._decorationsTree0.delete(node);
+        }
+    }
+    getNodeRange(host, node) {
+        const versionId = host.getVersionId();
+        if (node.cachedVersionId !== versionId) {
+            this._resolveNode(node, versionId);
+        }
+        if (node.range === null) {
+            node.range = host.getRangeAt(node.cachedAbsoluteStart, node.cachedAbsoluteEnd);
+        }
+        return node.range;
+    }
+    _resolveNode(node, cachedVersionId) {
+        if (isNodeInjectedText(node)) {
+            this._injectedTextDecorationsTree.resolveNode(node, cachedVersionId);
+        }
+        else if (isNodeInOverviewRuler(node)) {
+            this._decorationsTree1.resolveNode(node, cachedVersionId);
+        }
+        else {
+            this._decorationsTree0.resolveNode(node, cachedVersionId);
+        }
+    }
+    acceptReplace(offset, length, textLength, forceMoveMarkers) {
+        this._decorationsTree0.acceptReplace(offset, length, textLength, forceMoveMarkers);
+        this._decorationsTree1.acceptReplace(offset, length, textLength, forceMoveMarkers);
+        this._injectedTextDecorationsTree.acceptReplace(offset, length, textLength, forceMoveMarkers);
+    }
+}
+function cleanClassName(className) {
+    return className.replace(/[^a-z0-9\-_]/gi, ' ');
+}
+class DecorationOptions {
+    constructor(options) {
+        this.color = options.color || '';
+        this.darkColor = options.darkColor || '';
+    }
+}
+export class ModelDecorationOverviewRulerOptions extends DecorationOptions {
+    constructor(options) {
+        super(options);
+        this._resolvedColor = null;
+        this.position = (typeof options.position === 'number' ? options.position : model.OverviewRulerLane.Center);
+    }
+    getColor(theme) {
+        if (!this._resolvedColor) {
+            if (theme.type !== 'light' && this.darkColor) {
+                this._resolvedColor = this._resolveColor(this.darkColor, theme);
+            }
+            else {
+                this._resolvedColor = this._resolveColor(this.color, theme);
+            }
+        }
+        return this._resolvedColor;
+    }
+    invalidateCachedColor() {
+        this._resolvedColor = null;
+    }
+    _resolveColor(color, theme) {
+        if (typeof color === 'string') {
+            return color;
+        }
+        const c = color ? theme.getColor(color.id) : null;
+        if (!c) {
+            return '';
+        }
+        return c.toString();
+    }
+}
+export class ModelDecorationGlyphMarginOptions {
+    constructor(options) {
+        this.position = options?.position ?? model.GlyphMarginLane.Center;
+        this.persistLane = options?.persistLane;
+    }
+}
+export class ModelDecorationMinimapOptions extends DecorationOptions {
+    constructor(options) {
+        super(options);
+        this.position = options.position;
+        this.sectionHeaderStyle = options.sectionHeaderStyle ?? null;
+        this.sectionHeaderText = options.sectionHeaderText ?? null;
+    }
+    getColor(theme) {
+        if (!this._resolvedColor) {
+            if (theme.type !== 'light' && this.darkColor) {
+                this._resolvedColor = this._resolveColor(this.darkColor, theme);
+            }
+            else {
+                this._resolvedColor = this._resolveColor(this.color, theme);
+            }
+        }
+        return this._resolvedColor;
+    }
+    invalidateCachedColor() {
+        this._resolvedColor = undefined;
+    }
+    _resolveColor(color, theme) {
+        if (typeof color === 'string') {
+            return Color.fromHex(color);
+        }
+        return theme.getColor(color.id);
+    }
+}
+export class ModelDecorationInjectedTextOptions {
+    static from(options) {
+        if (options instanceof ModelDecorationInjectedTextOptions) {
+            return options;
+        }
+        return new ModelDecorationInjectedTextOptions(options);
+    }
+    constructor(options) {
+        this.content = options.content || '';
+        this.inlineClassName = options.inlineClassName || null;
+        this.inlineClassNameAffectsLetterSpacing = options.inlineClassNameAffectsLetterSpacing || false;
+        this.attachedData = options.attachedData || null;
+        this.cursorStops = options.cursorStops || null;
+    }
+}
+export class ModelDecorationOptions {
+    static register(options) {
+        return new ModelDecorationOptions(options);
+    }
+    static createDynamic(options) {
+        return new ModelDecorationOptions(options);
+    }
+    constructor(options) {
+        this.description = options.description;
+        this.blockClassName = options.blockClassName ? cleanClassName(options.blockClassName) : null;
+        this.blockDoesNotCollapse = options.blockDoesNotCollapse ?? null;
+        this.blockIsAfterEnd = options.blockIsAfterEnd ?? null;
+        this.blockPadding = options.blockPadding ?? null;
+        this.stickiness = options.stickiness || 0 /* model.TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */;
+        this.zIndex = options.zIndex || 0;
+        this.className = options.className ? cleanClassName(options.className) : null;
+        this.shouldFillLineOnLineBreak = options.shouldFillLineOnLineBreak ?? null;
+        this.hoverMessage = options.hoverMessage || null;
+        this.glyphMarginHoverMessage = options.glyphMarginHoverMessage || null;
+        this.lineNumberHoverMessage = options.lineNumberHoverMessage || null;
+        this.isWholeLine = options.isWholeLine || false;
+        this.showIfCollapsed = options.showIfCollapsed || false;
+        this.collapseOnReplaceEdit = options.collapseOnReplaceEdit || false;
+        this.overviewRuler = options.overviewRuler ? new ModelDecorationOverviewRulerOptions(options.overviewRuler) : null;
+        this.minimap = options.minimap ? new ModelDecorationMinimapOptions(options.minimap) : null;
+        this.glyphMargin = options.glyphMarginClassName ? new ModelDecorationGlyphMarginOptions(options.glyphMargin) : null;
+        this.glyphMarginClassName = options.glyphMarginClassName ? cleanClassName(options.glyphMarginClassName) : null;
+        this.linesDecorationsClassName = options.linesDecorationsClassName ? cleanClassName(options.linesDecorationsClassName) : null;
+        this.lineNumberClassName = options.lineNumberClassName ? cleanClassName(options.lineNumberClassName) : null;
+        this.linesDecorationsTooltip = options.linesDecorationsTooltip ? strings.htmlAttributeEncodeValue(options.linesDecorationsTooltip) : null;
+        this.firstLineDecorationClassName = options.firstLineDecorationClassName ? cleanClassName(options.firstLineDecorationClassName) : null;
+        this.marginClassName = options.marginClassName ? cleanClassName(options.marginClassName) : null;
+        this.inlineClassName = options.inlineClassName ? cleanClassName(options.inlineClassName) : null;
+        this.inlineClassNameAffectsLetterSpacing = options.inlineClassNameAffectsLetterSpacing || false;
+        this.beforeContentClassName = options.beforeContentClassName ? cleanClassName(options.beforeContentClassName) : null;
+        this.afterContentClassName = options.afterContentClassName ? cleanClassName(options.afterContentClassName) : null;
+        this.after = options.after ? ModelDecorationInjectedTextOptions.from(options.after) : null;
+        this.before = options.before ? ModelDecorationInjectedTextOptions.from(options.before) : null;
+        this.hideInCommentTokens = options.hideInCommentTokens ?? false;
+        this.hideInStringTokens = options.hideInStringTokens ?? false;
+    }
+}
+ModelDecorationOptions.EMPTY = ModelDecorationOptions.register({ description: 'empty' });
+/**
+ * The order carefully matches the values of the enum.
+ */
+const TRACKED_RANGE_OPTIONS = [
+    ModelDecorationOptions.register({ description: 'tracked-range-always-grows-when-typing-at-edges', stickiness: 0 /* model.TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */ }),
+    ModelDecorationOptions.register({ description: 'tracked-range-never-grows-when-typing-at-edges', stickiness: 1 /* model.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */ }),
+    ModelDecorationOptions.register({ description: 'tracked-range-grows-only-when-typing-before', stickiness: 2 /* model.TrackedRangeStickiness.GrowsOnlyWhenTypingBefore */ }),
+    ModelDecorationOptions.register({ description: 'tracked-range-grows-only-when-typing-after', stickiness: 3 /* model.TrackedRangeStickiness.GrowsOnlyWhenTypingAfter */ }),
+];
+function _normalizeOptions(options) {
+    if (options instanceof ModelDecorationOptions) {
+        return options;
+    }
+    return ModelDecorationOptions.createDynamic(options);
+}
+class DidChangeDecorationsEmitter extends Disposable {
+    constructor(handleBeforeFire) {
+        super();
+        this.handleBeforeFire = handleBeforeFire;
+        this._actual = this._register(new Emitter());
+        this.event = this._actual.event;
+        this._affectedInjectedTextLines = null;
+        this._deferredCnt = 0;
+        this._shouldFireDeferred = false;
+        this._affectsMinimap = false;
+        this._affectsOverviewRuler = false;
+        this._affectsGlyphMargin = false;
+        this._affectsLineNumber = false;
+    }
+    beginDeferredEmit() {
+        this._deferredCnt++;
+    }
+    endDeferredEmit() {
+        this._deferredCnt--;
+        if (this._deferredCnt === 0) {
+            if (this._shouldFireDeferred) {
+                this.doFire();
+            }
+            this._affectedInjectedTextLines?.clear();
+            this._affectedInjectedTextLines = null;
+        }
+    }
+    recordLineAffectedByInjectedText(lineNumber) {
+        if (!this._affectedInjectedTextLines) {
+            this._affectedInjectedTextLines = new Set();
+        }
+        this._affectedInjectedTextLines.add(lineNumber);
+    }
+    checkAffectedAndFire(options) {
+        this._affectsMinimap ||= !!options.minimap?.position;
+        this._affectsOverviewRuler ||= !!options.overviewRuler?.color;
+        this._affectsGlyphMargin ||= !!options.glyphMarginClassName;
+        this._affectsLineNumber ||= !!options.lineNumberClassName;
+        this.tryFire();
+    }
+    fire() {
+        this._affectsMinimap = true;
+        this._affectsOverviewRuler = true;
+        this._affectsGlyphMargin = true;
+        this.tryFire();
+    }
+    tryFire() {
+        if (this._deferredCnt === 0) {
+            this.doFire();
+        }
+        else {
+            this._shouldFireDeferred = true;
+        }
+    }
+    doFire() {
+        this.handleBeforeFire(this._affectedInjectedTextLines);
+        const event = {
+            affectsMinimap: this._affectsMinimap,
+            affectsOverviewRuler: this._affectsOverviewRuler,
+            affectsGlyphMargin: this._affectsGlyphMargin,
+            affectsLineNumber: this._affectsLineNumber,
+        };
+        this._shouldFireDeferred = false;
+        this._affectsMinimap = false;
+        this._affectsOverviewRuler = false;
+        this._affectsGlyphMargin = false;
+        this._actual.fire(event);
+    }
+}
+//#endregion
+class DidChangeContentEmitter extends Disposable {
+    constructor() {
+        super();
+        /**
+         * Both `fastEvent` and `slowEvent` work the same way and contain the same events, but first we invoke `fastEvent` and then `slowEvent`.
+         */
+        this._fastEmitter = this._register(new Emitter());
+        this.fastEvent = this._fastEmitter.event;
+        this._slowEmitter = this._register(new Emitter());
+        this.slowEvent = this._slowEmitter.event;
+        this._deferredCnt = 0;
+        this._deferredEvent = null;
+    }
+    beginDeferredEmit() {
+        this._deferredCnt++;
+    }
+    endDeferredEmit(resultingSelection = null) {
+        this._deferredCnt--;
+        if (this._deferredCnt === 0) {
+            if (this._deferredEvent !== null) {
+                this._deferredEvent.rawContentChangedEvent.resultingSelection = resultingSelection;
+                const e = this._deferredEvent;
+                this._deferredEvent = null;
+                this._fastEmitter.fire(e);
+                this._slowEmitter.fire(e);
+            }
+        }
+    }
+    fire(e) {
+        if (this._deferredCnt > 0) {
+            if (this._deferredEvent) {
+                this._deferredEvent = this._deferredEvent.merge(e);
+            }
+            else {
+                this._deferredEvent = e;
+            }
+            return;
+        }
+        this._fastEmitter.fire(e);
+        this._slowEmitter.fire(e);
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/textModelPart.js

@@ -0,0 +1,20 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Disposable } from '../../../base/common/lifecycle.js';
+export class TextModelPart extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._isDisposed = false;
+    }
+    dispose() {
+        super.dispose();
+        this._isDisposed = true;
+    }
+    assertNotDisposed() {
+        if (this._isDisposed) {
+            throw new Error('TextModelPart is disposed!');
+        }
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js

@@ -0,0 +1,452 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as strings from '../../../base/common/strings.js';
+import { getMapForWordSeparators } from '../core/wordCharacterClassifier.js';
+import { Position } from '../core/position.js';
+import { Range } from '../core/range.js';
+import { FindMatch, SearchData } from '../model.js';
+const LIMIT_FIND_COUNT = 999;
+export class SearchParams {
+    constructor(searchString, isRegex, matchCase, wordSeparators) {
+        this.searchString = searchString;
+        this.isRegex = isRegex;
+        this.matchCase = matchCase;
+        this.wordSeparators = wordSeparators;
+    }
+    parseSearchRequest() {
+        if (this.searchString === '') {
+            return null;
+        }
+        // Try to create a RegExp out of the params
+        let multiline;
+        if (this.isRegex) {
+            multiline = isMultilineRegexSource(this.searchString);
+        }
+        else {
+            multiline = (this.searchString.indexOf('\n') >= 0);
+        }
+        let regex = null;
+        try {
+            regex = strings.createRegExp(this.searchString, this.isRegex, {
+                matchCase: this.matchCase,
+                wholeWord: false,
+                multiline: multiline,
+                global: true,
+                unicode: true
+            });
+        }
+        catch (err) {
+            return null;
+        }
+        if (!regex) {
+            return null;
+        }
+        let canUseSimpleSearch = (!this.isRegex && !multiline);
+        if (canUseSimpleSearch && this.searchString.toLowerCase() !== this.searchString.toUpperCase()) {
+            // casing might make a difference
+            canUseSimpleSearch = this.matchCase;
+        }
+        return new SearchData(regex, this.wordSeparators ? getMapForWordSeparators(this.wordSeparators, []) : null, canUseSimpleSearch ? this.searchString : null);
+    }
+}
+export function isMultilineRegexSource(searchString) {
+    if (!searchString || searchString.length === 0) {
+        return false;
+    }
+    for (let i = 0, len = searchString.length; i < len; i++) {
+        const chCode = searchString.charCodeAt(i);
+        if (chCode === 10 /* CharCode.LineFeed */) {
+            return true;
+        }
+        if (chCode === 92 /* CharCode.Backslash */) {
+            // move to next char
+            i++;
+            if (i >= len) {
+                // string ends with a \
+                break;
+            }
+            const nextChCode = searchString.charCodeAt(i);
+            if (nextChCode === 110 /* CharCode.n */ || nextChCode === 114 /* CharCode.r */ || nextChCode === 87 /* CharCode.W */) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function createFindMatch(range, rawMatches, captureMatches) {
+    if (!captureMatches) {
+        return new FindMatch(range, null);
+    }
+    const matches = [];
+    for (let i = 0, len = rawMatches.length; i < len; i++) {
+        matches[i] = rawMatches[i];
+    }
+    return new FindMatch(range, matches);
+}
+class LineFeedCounter {
+    constructor(text) {
+        const lineFeedsOffsets = [];
+        let lineFeedsOffsetsLen = 0;
+        for (let i = 0, textLen = text.length; i < textLen; i++) {
+            if (text.charCodeAt(i) === 10 /* CharCode.LineFeed */) {
+                lineFeedsOffsets[lineFeedsOffsetsLen++] = i;
+            }
+        }
+        this._lineFeedsOffsets = lineFeedsOffsets;
+    }
+    findLineFeedCountBeforeOffset(offset) {
+        const lineFeedsOffsets = this._lineFeedsOffsets;
+        let min = 0;
+        let max = lineFeedsOffsets.length - 1;
+        if (max === -1) {
+            // no line feeds
+            return 0;
+        }
+        if (offset <= lineFeedsOffsets[0]) {
+            // before first line feed
+            return 0;
+        }
+        while (min < max) {
+            const mid = min + ((max - min) / 2 >> 0);
+            if (lineFeedsOffsets[mid] >= offset) {
+                max = mid - 1;
+            }
+            else {
+                if (lineFeedsOffsets[mid + 1] >= offset) {
+                    // bingo!
+                    min = mid;
+                    max = mid;
+                }
+                else {
+                    min = mid + 1;
+                }
+            }
+        }
+        return min + 1;
+    }
+}
+export class TextModelSearch {
+    static findMatches(model, searchParams, searchRange, captureMatches, limitResultCount) {
+        const searchData = searchParams.parseSearchRequest();
+        if (!searchData) {
+            return [];
+        }
+        if (searchData.regex.multiline) {
+            return this._doFindMatchesMultiline(model, searchRange, new Searcher(searchData.wordSeparators, searchData.regex), captureMatches, limitResultCount);
+        }
+        return this._doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount);
+    }
+    /**
+     * Multiline search always executes on the lines concatenated with \n.
+     * We must therefore compensate for the count of \n in case the model is CRLF
+     */
+    static _getMultilineMatchRange(model, deltaOffset, text, lfCounter, matchIndex, match0) {
+        let startOffset;
+        let lineFeedCountBeforeMatch = 0;
+        if (lfCounter) {
+            lineFeedCountBeforeMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex);
+            startOffset = deltaOffset + matchIndex + lineFeedCountBeforeMatch /* add as many \r as there were \n */;
+        }
+        else {
+            startOffset = deltaOffset + matchIndex;
+        }
+        let endOffset;
+        if (lfCounter) {
+            const lineFeedCountBeforeEndOfMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex + match0.length);
+            const lineFeedCountInMatch = lineFeedCountBeforeEndOfMatch - lineFeedCountBeforeMatch;
+            endOffset = startOffset + match0.length + lineFeedCountInMatch /* add as many \r as there were \n */;
+        }
+        else {
+            endOffset = startOffset + match0.length;
+        }
+        const startPosition = model.getPositionAt(startOffset);
+        const endPosition = model.getPositionAt(endOffset);
+        return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);
+    }
+    static _doFindMatchesMultiline(model, searchRange, searcher, captureMatches, limitResultCount) {
+        const deltaOffset = model.getOffsetAt(searchRange.getStartPosition());
+        // We always execute multiline search over the lines joined with \n
+        // This makes it that \n will match the EOL for both CRLF and LF models
+        // We compensate for offset errors in `_getMultilineMatchRange`
+        const text = model.getValueInRange(searchRange, 1 /* EndOfLinePreference.LF */);
+        const lfCounter = (model.getEOL() === '\r\n' ? new LineFeedCounter(text) : null);
+        const result = [];
+        let counter = 0;
+        let m;
+        searcher.reset(0);
+        while ((m = searcher.next(text))) {
+            result[counter++] = createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);
+            if (counter >= limitResultCount) {
+                return result;
+            }
+        }
+        return result;
+    }
+    static _doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount) {
+        const result = [];
+        let resultLen = 0;
+        // Early case for a search range that starts & stops on the same line number
+        if (searchRange.startLineNumber === searchRange.endLineNumber) {
+            const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1, searchRange.endColumn - 1);
+            resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);
+            return result;
+        }
+        // Collect results from first line
+        const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1);
+        resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);
+        // Collect results from middle lines
+        for (let lineNumber = searchRange.startLineNumber + 1; lineNumber < searchRange.endLineNumber && resultLen < limitResultCount; lineNumber++) {
+            resultLen = this._findMatchesInLine(searchData, model.getLineContent(lineNumber), lineNumber, 0, resultLen, result, captureMatches, limitResultCount);
+        }
+        // Collect results from last line
+        if (resultLen < limitResultCount) {
+            const text = model.getLineContent(searchRange.endLineNumber).substring(0, searchRange.endColumn - 1);
+            resultLen = this._findMatchesInLine(searchData, text, searchRange.endLineNumber, 0, resultLen, result, captureMatches, limitResultCount);
+        }
+        return result;
+    }
+    static _findMatchesInLine(searchData, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {
+        const wordSeparators = searchData.wordSeparators;
+        if (!captureMatches && searchData.simpleSearch) {
+            const searchString = searchData.simpleSearch;
+            const searchStringLen = searchString.length;
+            const textLength = text.length;
+            let lastMatchIndex = -searchStringLen;
+            while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {
+                if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {
+                    result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);
+                    if (resultLen >= limitResultCount) {
+                        return resultLen;
+                    }
+                }
+            }
+            return resultLen;
+        }
+        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);
+        let m;
+        // Reset regex to search from the beginning
+        searcher.reset(0);
+        do {
+            m = searcher.next(text);
+            if (m) {
+                result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);
+                if (resultLen >= limitResultCount) {
+                    return resultLen;
+                }
+            }
+        } while (m);
+        return resultLen;
+    }
+    static findNextMatch(model, searchParams, searchStart, captureMatches) {
+        const searchData = searchParams.parseSearchRequest();
+        if (!searchData) {
+            return null;
+        }
+        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);
+        if (searchData.regex.multiline) {
+            return this._doFindNextMatchMultiline(model, searchStart, searcher, captureMatches);
+        }
+        return this._doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches);
+    }
+    static _doFindNextMatchMultiline(model, searchStart, searcher, captureMatches) {
+        const searchTextStart = new Position(searchStart.lineNumber, 1);
+        const deltaOffset = model.getOffsetAt(searchTextStart);
+        const lineCount = model.getLineCount();
+        // We always execute multiline search over the lines joined with \n
+        // This makes it that \n will match the EOL for both CRLF and LF models
+        // We compensate for offset errors in `_getMultilineMatchRange`
+        const text = model.getValueInRange(new Range(searchTextStart.lineNumber, searchTextStart.column, lineCount, model.getLineMaxColumn(lineCount)), 1 /* EndOfLinePreference.LF */);
+        const lfCounter = (model.getEOL() === '\r\n' ? new LineFeedCounter(text) : null);
+        searcher.reset(searchStart.column - 1);
+        const m = searcher.next(text);
+        if (m) {
+            return createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);
+        }
+        if (searchStart.lineNumber !== 1 || searchStart.column !== 1) {
+            // Try again from the top
+            return this._doFindNextMatchMultiline(model, new Position(1, 1), searcher, captureMatches);
+        }
+        return null;
+    }
+    static _doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches) {
+        const lineCount = model.getLineCount();
+        const startLineNumber = searchStart.lineNumber;
+        // Look in first line
+        const text = model.getLineContent(startLineNumber);
+        const r = this._findFirstMatchInLine(searcher, text, startLineNumber, searchStart.column, captureMatches);
+        if (r) {
+            return r;
+        }
+        for (let i = 1; i <= lineCount; i++) {
+            const lineIndex = (startLineNumber + i - 1) % lineCount;
+            const text = model.getLineContent(lineIndex + 1);
+            const r = this._findFirstMatchInLine(searcher, text, lineIndex + 1, 1, captureMatches);
+            if (r) {
+                return r;
+            }
+        }
+        return null;
+    }
+    static _findFirstMatchInLine(searcher, text, lineNumber, fromColumn, captureMatches) {
+        // Set regex to search from column
+        searcher.reset(fromColumn - 1);
+        const m = searcher.next(text);
+        if (m) {
+            return createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);
+        }
+        return null;
+    }
+    static findPreviousMatch(model, searchParams, searchStart, captureMatches) {
+        const searchData = searchParams.parseSearchRequest();
+        if (!searchData) {
+            return null;
+        }
+        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);
+        if (searchData.regex.multiline) {
+            return this._doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches);
+        }
+        return this._doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches);
+    }
+    static _doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches) {
+        const matches = this._doFindMatchesMultiline(model, new Range(1, 1, searchStart.lineNumber, searchStart.column), searcher, captureMatches, 10 * LIMIT_FIND_COUNT);
+        if (matches.length > 0) {
+            return matches[matches.length - 1];
+        }
+        const lineCount = model.getLineCount();
+        if (searchStart.lineNumber !== lineCount || searchStart.column !== model.getLineMaxColumn(lineCount)) {
+            // Try again with all content
+            return this._doFindPreviousMatchMultiline(model, new Position(lineCount, model.getLineMaxColumn(lineCount)), searcher, captureMatches);
+        }
+        return null;
+    }
+    static _doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches) {
+        const lineCount = model.getLineCount();
+        const startLineNumber = searchStart.lineNumber;
+        // Look in first line
+        const text = model.getLineContent(startLineNumber).substring(0, searchStart.column - 1);
+        const r = this._findLastMatchInLine(searcher, text, startLineNumber, captureMatches);
+        if (r) {
+            return r;
+        }
+        for (let i = 1; i <= lineCount; i++) {
+            const lineIndex = (lineCount + startLineNumber - i - 1) % lineCount;
+            const text = model.getLineContent(lineIndex + 1);
+            const r = this._findLastMatchInLine(searcher, text, lineIndex + 1, captureMatches);
+            if (r) {
+                return r;
+            }
+        }
+        return null;
+    }
+    static _findLastMatchInLine(searcher, text, lineNumber, captureMatches) {
+        let bestResult = null;
+        let m;
+        searcher.reset(0);
+        while ((m = searcher.next(text))) {
+            bestResult = createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);
+        }
+        return bestResult;
+    }
+}
+function leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {
+    if (matchStartIndex === 0) {
+        // Match starts at start of string
+        return true;
+    }
+    const charBefore = text.charCodeAt(matchStartIndex - 1);
+    if (wordSeparators.get(charBefore) !== 0 /* WordCharacterClass.Regular */) {
+        // The character before the match is a word separator
+        return true;
+    }
+    if (charBefore === 13 /* CharCode.CarriageReturn */ || charBefore === 10 /* CharCode.LineFeed */) {
+        // The character before the match is line break or carriage return.
+        return true;
+    }
+    if (matchLength > 0) {
+        const firstCharInMatch = text.charCodeAt(matchStartIndex);
+        if (wordSeparators.get(firstCharInMatch) !== 0 /* WordCharacterClass.Regular */) {
+            // The first character inside the match is a word separator
+            return true;
+        }
+    }
+    return false;
+}
+function rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {
+    if (matchStartIndex + matchLength === textLength) {
+        // Match ends at end of string
+        return true;
+    }
+    const charAfter = text.charCodeAt(matchStartIndex + matchLength);
+    if (wordSeparators.get(charAfter) !== 0 /* WordCharacterClass.Regular */) {
+        // The character after the match is a word separator
+        return true;
+    }
+    if (charAfter === 13 /* CharCode.CarriageReturn */ || charAfter === 10 /* CharCode.LineFeed */) {
+        // The character after the match is line break or carriage return.
+        return true;
+    }
+    if (matchLength > 0) {
+        const lastCharInMatch = text.charCodeAt(matchStartIndex + matchLength - 1);
+        if (wordSeparators.get(lastCharInMatch) !== 0 /* WordCharacterClass.Regular */) {
+            // The last character in the match is a word separator
+            return true;
+        }
+    }
+    return false;
+}
+export function isValidMatch(wordSeparators, text, textLength, matchStartIndex, matchLength) {
+    return (leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength)
+        && rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength));
+}
+export class Searcher {
+    constructor(wordSeparators, searchRegex) {
+        this._wordSeparators = wordSeparators;
+        this._searchRegex = searchRegex;
+        this._prevMatchStartIndex = -1;
+        this._prevMatchLength = 0;
+    }
+    reset(lastIndex) {
+        this._searchRegex.lastIndex = lastIndex;
+        this._prevMatchStartIndex = -1;
+        this._prevMatchLength = 0;
+    }
+    next(text) {
+        const textLength = text.length;
+        let m;
+        do {
+            if (this._prevMatchStartIndex + this._prevMatchLength === textLength) {
+                // Reached the end of the line
+                return null;
+            }
+            m = this._searchRegex.exec(text);
+            if (!m) {
+                return null;
+            }
+            const matchStartIndex = m.index;
+            const matchLength = m[0].length;
+            if (matchStartIndex === this._prevMatchStartIndex && matchLength === this._prevMatchLength) {
+                if (matchLength === 0) {
+                    // the search result is an empty string and won't advance `regex.lastIndex`, so `regex.exec` will stuck here
+                    // we attempt to recover from that by advancing by two if surrogate pair found and by one otherwise
+                    if (strings.getNextCodePoint(text, textLength, this._searchRegex.lastIndex) > 0xFFFF) {
+                        this._searchRegex.lastIndex += 2;
+                    }
+                    else {
+                        this._searchRegex.lastIndex += 1;
+                    }
+                    continue;
+                }
+                // Exit early if the regex matches the same range twice
+                return null;
+            }
+            this._prevMatchStartIndex = matchStartIndex;
+            this._prevMatchLength = matchLength;
+            if (!this._wordSeparators || isValidMatch(this._wordSeparators, text, textLength, matchStartIndex, matchLength)) {
+                return m;
+            }
+        } while (m);
+        return null;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/textModelText.js

@@ -0,0 +1,20 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { AbstractText } from '../core/textEdit.js';
+import { TextLength } from '../core/textLength.js';
+export class TextModelText extends AbstractText {
+    constructor(_textModel) {
+        super();
+        this._textModel = _textModel;
+    }
+    getValueOfRange(range) {
+        return this._textModel.getValueInRange(range);
+    }
+    get length() {
+        const lastLineNumber = this._textModel.getLineCount();
+        const lastLineLen = this._textModel.getLineLength(lastLineNumber);
+        return new TextLength(lastLineNumber - 1, lastLineLen);
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/textModelTokens.js

@@ -0,0 +1,429 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { runWhenGlobalIdle } from '../../../base/common/async.js';
+import { BugIndicatingError, onUnexpectedError } from '../../../base/common/errors.js';
+import { setTimeout0 } from '../../../base/common/platform.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
+import { countEOL } from '../core/eolCounter.js';
+import { LineRange } from '../core/lineRange.js';
+import { OffsetRange } from '../core/offsetRange.js';
+import { nullTokenizeEncoded } from '../languages/nullTokenize.js';
+import { FixedArray } from './fixedArray.js';
+import { ContiguousMultilineTokensBuilder } from '../tokens/contiguousMultilineTokensBuilder.js';
+import { LineTokens } from '../tokens/lineTokens.js';
+export class TokenizerWithStateStore {
+    constructor(lineCount, tokenizationSupport) {
+        this.tokenizationSupport = tokenizationSupport;
+        this.initialState = this.tokenizationSupport.getInitialState();
+        this.store = new TrackingTokenizationStateStore(lineCount);
+    }
+    getStartState(lineNumber) {
+        return this.store.getStartState(lineNumber, this.initialState);
+    }
+    getFirstInvalidLine() {
+        return this.store.getFirstInvalidLine(this.initialState);
+    }
+}
+export class TokenizerWithStateStoreAndTextModel extends TokenizerWithStateStore {
+    constructor(lineCount, tokenizationSupport, _textModel, _languageIdCodec) {
+        super(lineCount, tokenizationSupport);
+        this._textModel = _textModel;
+        this._languageIdCodec = _languageIdCodec;
+    }
+    updateTokensUntilLine(builder, lineNumber) {
+        const languageId = this._textModel.getLanguageId();
+        while (true) {
+            const lineToTokenize = this.getFirstInvalidLine();
+            if (!lineToTokenize || lineToTokenize.lineNumber > lineNumber) {
+                break;
+            }
+            const text = this._textModel.getLineContent(lineToTokenize.lineNumber);
+            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, text, true, lineToTokenize.startState);
+            builder.add(lineToTokenize.lineNumber, r.tokens);
+            this.store.setEndState(lineToTokenize.lineNumber, r.endState);
+        }
+    }
+    /** assumes state is up to date */
+    getTokenTypeIfInsertingCharacter(position, character) {
+        // TODO@hediet: use tokenizeLineWithEdit
+        const lineStartState = this.getStartState(position.lineNumber);
+        if (!lineStartState) {
+            return 0 /* StandardTokenType.Other */;
+        }
+        const languageId = this._textModel.getLanguageId();
+        const lineContent = this._textModel.getLineContent(position.lineNumber);
+        // Create the text as if `character` was inserted
+        const text = (lineContent.substring(0, position.column - 1)
+            + character
+            + lineContent.substring(position.column - 1));
+        const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, text, true, lineStartState);
+        const lineTokens = new LineTokens(r.tokens, text, this._languageIdCodec);
+        if (lineTokens.getCount() === 0) {
+            return 0 /* StandardTokenType.Other */;
+        }
+        const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);
+        return lineTokens.getStandardTokenType(tokenIndex);
+    }
+    /** assumes state is up to date */
+    tokenizeLineWithEdit(position, length, newText) {
+        const lineNumber = position.lineNumber;
+        const column = position.column;
+        const lineStartState = this.getStartState(lineNumber);
+        if (!lineStartState) {
+            return null;
+        }
+        const curLineContent = this._textModel.getLineContent(lineNumber);
+        const newLineContent = curLineContent.substring(0, column - 1)
+            + newText + curLineContent.substring(column - 1 + length);
+        const languageId = this._textModel.getLanguageIdAtPosition(lineNumber, 0);
+        const result = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, newLineContent, true, lineStartState);
+        const lineTokens = new LineTokens(result.tokens, newLineContent, this._languageIdCodec);
+        return lineTokens;
+    }
+    hasAccurateTokensForLine(lineNumber) {
+        const firstInvalidLineNumber = this.store.getFirstInvalidEndStateLineNumberOrMax();
+        return (lineNumber < firstInvalidLineNumber);
+    }
+    isCheapToTokenize(lineNumber) {
+        const firstInvalidLineNumber = this.store.getFirstInvalidEndStateLineNumberOrMax();
+        if (lineNumber < firstInvalidLineNumber) {
+            return true;
+        }
+        if (lineNumber === firstInvalidLineNumber
+            && this._textModel.getLineLength(lineNumber) < 2048 /* Constants.CHEAP_TOKENIZATION_LENGTH_LIMIT */) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * The result is not cached.
+     */
+    tokenizeHeuristically(builder, startLineNumber, endLineNumber) {
+        if (endLineNumber <= this.store.getFirstInvalidEndStateLineNumberOrMax()) {
+            // nothing to do
+            return { heuristicTokens: false };
+        }
+        if (startLineNumber <= this.store.getFirstInvalidEndStateLineNumberOrMax()) {
+            // tokenization has reached the viewport start...
+            this.updateTokensUntilLine(builder, endLineNumber);
+            return { heuristicTokens: false };
+        }
+        let state = this.guessStartState(startLineNumber);
+        const languageId = this._textModel.getLanguageId();
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const text = this._textModel.getLineContent(lineNumber);
+            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, text, true, state);
+            builder.add(lineNumber, r.tokens);
+            state = r.endState;
+        }
+        return { heuristicTokens: true };
+    }
+    guessStartState(lineNumber) {
+        let nonWhitespaceColumn = this._textModel.getLineFirstNonWhitespaceColumn(lineNumber);
+        const likelyRelevantLines = [];
+        let initialState = null;
+        for (let i = lineNumber - 1; nonWhitespaceColumn > 1 && i >= 1; i--) {
+            const newNonWhitespaceIndex = this._textModel.getLineFirstNonWhitespaceColumn(i);
+            // Ignore lines full of whitespace
+            if (newNonWhitespaceIndex === 0) {
+                continue;
+            }
+            if (newNonWhitespaceIndex < nonWhitespaceColumn) {
+                likelyRelevantLines.push(this._textModel.getLineContent(i));
+                nonWhitespaceColumn = newNonWhitespaceIndex;
+                initialState = this.getStartState(i);
+                if (initialState) {
+                    break;
+                }
+            }
+        }
+        if (!initialState) {
+            initialState = this.tokenizationSupport.getInitialState();
+        }
+        likelyRelevantLines.reverse();
+        const languageId = this._textModel.getLanguageId();
+        let state = initialState;
+        for (const line of likelyRelevantLines) {
+            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, line, false, state);
+            state = r.endState;
+        }
+        return state;
+    }
+}
+/**
+ * **Invariant:**
+ * If the text model is retokenized from line 1 to {@link getFirstInvalidEndStateLineNumber}() - 1,
+ * then the recomputed end state for line l will be equal to {@link getEndState}(l).
+ */
+export class TrackingTokenizationStateStore {
+    constructor(lineCount) {
+        this.lineCount = lineCount;
+        this._tokenizationStateStore = new TokenizationStateStore();
+        this._invalidEndStatesLineNumbers = new RangePriorityQueueImpl();
+        this._invalidEndStatesLineNumbers.addRange(new OffsetRange(1, lineCount + 1));
+    }
+    getEndState(lineNumber) {
+        return this._tokenizationStateStore.getEndState(lineNumber);
+    }
+    /**
+     * @returns if the end state has changed.
+     */
+    setEndState(lineNumber, state) {
+        if (!state) {
+            throw new BugIndicatingError('Cannot set null/undefined state');
+        }
+        this._invalidEndStatesLineNumbers.delete(lineNumber);
+        const r = this._tokenizationStateStore.setEndState(lineNumber, state);
+        if (r && lineNumber < this.lineCount) {
+            // because the state changed, we cannot trust the next state anymore and have to invalidate it.
+            this._invalidEndStatesLineNumbers.addRange(new OffsetRange(lineNumber + 1, lineNumber + 2));
+        }
+        return r;
+    }
+    acceptChange(range, newLineCount) {
+        this.lineCount += newLineCount - range.length;
+        this._tokenizationStateStore.acceptChange(range, newLineCount);
+        this._invalidEndStatesLineNumbers.addRangeAndResize(new OffsetRange(range.startLineNumber, range.endLineNumberExclusive), newLineCount);
+    }
+    acceptChanges(changes) {
+        for (const c of changes) {
+            const [eolCount] = countEOL(c.text);
+            this.acceptChange(new LineRange(c.range.startLineNumber, c.range.endLineNumber + 1), eolCount + 1);
+        }
+    }
+    invalidateEndStateRange(range) {
+        this._invalidEndStatesLineNumbers.addRange(new OffsetRange(range.startLineNumber, range.endLineNumberExclusive));
+    }
+    getFirstInvalidEndStateLineNumber() { return this._invalidEndStatesLineNumbers.min; }
+    getFirstInvalidEndStateLineNumberOrMax() {
+        return this.getFirstInvalidEndStateLineNumber() || Number.MAX_SAFE_INTEGER;
+    }
+    allStatesValid() { return this._invalidEndStatesLineNumbers.min === null; }
+    getStartState(lineNumber, initialState) {
+        if (lineNumber === 1) {
+            return initialState;
+        }
+        return this.getEndState(lineNumber - 1);
+    }
+    getFirstInvalidLine(initialState) {
+        const lineNumber = this.getFirstInvalidEndStateLineNumber();
+        if (lineNumber === null) {
+            return null;
+        }
+        const startState = this.getStartState(lineNumber, initialState);
+        if (!startState) {
+            throw new BugIndicatingError('Start state must be defined');
+        }
+        return { lineNumber, startState };
+    }
+}
+export class TokenizationStateStore {
+    constructor() {
+        this._lineEndStates = new FixedArray(null);
+    }
+    getEndState(lineNumber) {
+        return this._lineEndStates.get(lineNumber);
+    }
+    setEndState(lineNumber, state) {
+        const oldState = this._lineEndStates.get(lineNumber);
+        if (oldState && oldState.equals(state)) {
+            return false;
+        }
+        this._lineEndStates.set(lineNumber, state);
+        return true;
+    }
+    acceptChange(range, newLineCount) {
+        let length = range.length;
+        if (newLineCount > 0 && length > 0) {
+            // Keep the last state, even though it is unrelated.
+            // But if the new state happens to agree with this last state, then we know we can stop tokenizing.
+            length--;
+            newLineCount--;
+        }
+        this._lineEndStates.replace(range.startLineNumber, length, newLineCount);
+    }
+}
+export class RangePriorityQueueImpl {
+    constructor() {
+        this._ranges = [];
+    }
+    get min() {
+        if (this._ranges.length === 0) {
+            return null;
+        }
+        return this._ranges[0].start;
+    }
+    delete(value) {
+        const idx = this._ranges.findIndex(r => r.contains(value));
+        if (idx !== -1) {
+            const range = this._ranges[idx];
+            if (range.start === value) {
+                if (range.endExclusive === value + 1) {
+                    this._ranges.splice(idx, 1);
+                }
+                else {
+                    this._ranges[idx] = new OffsetRange(value + 1, range.endExclusive);
+                }
+            }
+            else {
+                if (range.endExclusive === value + 1) {
+                    this._ranges[idx] = new OffsetRange(range.start, value);
+                }
+                else {
+                    this._ranges.splice(idx, 1, new OffsetRange(range.start, value), new OffsetRange(value + 1, range.endExclusive));
+                }
+            }
+        }
+    }
+    addRange(range) {
+        OffsetRange.addRange(range, this._ranges);
+    }
+    addRangeAndResize(range, newLength) {
+        let idxFirstMightBeIntersecting = 0;
+        while (!(idxFirstMightBeIntersecting >= this._ranges.length || range.start <= this._ranges[idxFirstMightBeIntersecting].endExclusive)) {
+            idxFirstMightBeIntersecting++;
+        }
+        let idxFirstIsAfter = idxFirstMightBeIntersecting;
+        while (!(idxFirstIsAfter >= this._ranges.length || range.endExclusive < this._ranges[idxFirstIsAfter].start)) {
+            idxFirstIsAfter++;
+        }
+        const delta = newLength - range.length;
+        for (let i = idxFirstIsAfter; i < this._ranges.length; i++) {
+            this._ranges[i] = this._ranges[i].delta(delta);
+        }
+        if (idxFirstMightBeIntersecting === idxFirstIsAfter) {
+            const newRange = new OffsetRange(range.start, range.start + newLength);
+            if (!newRange.isEmpty) {
+                this._ranges.splice(idxFirstMightBeIntersecting, 0, newRange);
+            }
+        }
+        else {
+            const start = Math.min(range.start, this._ranges[idxFirstMightBeIntersecting].start);
+            const endEx = Math.max(range.endExclusive, this._ranges[idxFirstIsAfter - 1].endExclusive);
+            const newRange = new OffsetRange(start, endEx + delta);
+            if (!newRange.isEmpty) {
+                this._ranges.splice(idxFirstMightBeIntersecting, idxFirstIsAfter - idxFirstMightBeIntersecting, newRange);
+            }
+            else {
+                this._ranges.splice(idxFirstMightBeIntersecting, idxFirstIsAfter - idxFirstMightBeIntersecting);
+            }
+        }
+    }
+    toString() {
+        return this._ranges.map(r => r.toString()).join(' + ');
+    }
+}
+function safeTokenize(languageIdCodec, languageId, tokenizationSupport, text, hasEOL, state) {
+    let r = null;
+    if (tokenizationSupport) {
+        try {
+            r = tokenizationSupport.tokenizeEncoded(text, hasEOL, state.clone());
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    if (!r) {
+        r = nullTokenizeEncoded(languageIdCodec.encodeLanguageId(languageId), state);
+    }
+    LineTokens.convertToEndOffset(r.tokens, text.length);
+    return r;
+}
+export class DefaultBackgroundTokenizer {
+    constructor(_tokenizerWithStateStore, _backgroundTokenStore) {
+        this._tokenizerWithStateStore = _tokenizerWithStateStore;
+        this._backgroundTokenStore = _backgroundTokenStore;
+        this._isDisposed = false;
+        this._isScheduled = false;
+    }
+    dispose() {
+        this._isDisposed = true;
+    }
+    handleChanges() {
+        this._beginBackgroundTokenization();
+    }
+    _beginBackgroundTokenization() {
+        if (this._isScheduled || !this._tokenizerWithStateStore._textModel.isAttachedToEditor() || !this._hasLinesToTokenize()) {
+            return;
+        }
+        this._isScheduled = true;
+        runWhenGlobalIdle((deadline) => {
+            this._isScheduled = false;
+            this._backgroundTokenizeWithDeadline(deadline);
+        });
+    }
+    /**
+     * Tokenize until the deadline occurs, but try to yield every 1-2ms.
+     */
+    _backgroundTokenizeWithDeadline(deadline) {
+        // Read the time remaining from the `deadline` immediately because it is unclear
+        // if the `deadline` object will be valid after execution leaves this function.
+        const endTime = Date.now() + deadline.timeRemaining();
+        const execute = () => {
+            if (this._isDisposed || !this._tokenizerWithStateStore._textModel.isAttachedToEditor() || !this._hasLinesToTokenize()) {
+                // disposed in the meantime or detached or finished
+                return;
+            }
+            this._backgroundTokenizeForAtLeast1ms();
+            if (Date.now() < endTime) {
+                // There is still time before reaching the deadline, so yield to the browser and then
+                // continue execution
+                setTimeout0(execute);
+            }
+            else {
+                // The deadline has been reached, so schedule a new idle callback if necessary
+                this._beginBackgroundTokenization();
+            }
+        };
+        execute();
+    }
+    /**
+     * Tokenize for at least 1ms.
+     */
+    _backgroundTokenizeForAtLeast1ms() {
+        const lineCount = this._tokenizerWithStateStore._textModel.getLineCount();
+        const builder = new ContiguousMultilineTokensBuilder();
+        const sw = StopWatch.create(false);
+        do {
+            if (sw.elapsed() > 1) {
+                // the comparison is intentionally > 1 and not >= 1 to ensure that
+                // a full millisecond has elapsed, given how microseconds are rounded
+                // to milliseconds
+                break;
+            }
+            const tokenizedLineNumber = this._tokenizeOneInvalidLine(builder);
+            if (tokenizedLineNumber >= lineCount) {
+                break;
+            }
+        } while (this._hasLinesToTokenize());
+        this._backgroundTokenStore.setTokens(builder.finalize());
+        this.checkFinished();
+    }
+    _hasLinesToTokenize() {
+        if (!this._tokenizerWithStateStore) {
+            return false;
+        }
+        return !this._tokenizerWithStateStore.store.allStatesValid();
+    }
+    _tokenizeOneInvalidLine(builder) {
+        const firstInvalidLine = this._tokenizerWithStateStore?.getFirstInvalidLine();
+        if (!firstInvalidLine) {
+            return this._tokenizerWithStateStore._textModel.getLineCount() + 1;
+        }
+        this._tokenizerWithStateStore.updateTokensUntilLine(builder, firstInvalidLine.lineNumber);
+        return firstInvalidLine.lineNumber;
+    }
+    checkFinished() {
+        if (this._isDisposed) {
+            return;
+        }
+        if (this._tokenizerWithStateStore.store.allStatesValid()) {
+            this._backgroundTokenStore.backgroundTokenizationFinished();
+        }
+    }
+    requestTokens(startLineNumber, endLineNumberExclusive) {
+        this._tokenizerWithStateStore.store.invalidateEndStateRange(new LineRange(startLineNumber, endLineNumberExclusive));
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/tokenizationTextModelPart.js

@@ -0,0 +1,530 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var TokenizationTextModelPart_1;
+import { BugIndicatingError, onUnexpectedError } from '../../../base/common/errors.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { DisposableMap, DisposableStore, MutableDisposable } from '../../../base/common/lifecycle.js';
+import { countEOL } from '../core/eolCounter.js';
+import { LineRange } from '../core/lineRange.js';
+import { Position } from '../core/position.js';
+import { getWordAtText } from '../core/wordHelper.js';
+import { TokenizationRegistry, TreeSitterTokenizationRegistry } from '../languages.js';
+import { ILanguageService } from '../languages/language.js';
+import { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.js';
+import { TextModelPart } from './textModelPart.js';
+import { DefaultBackgroundTokenizer, TokenizerWithStateStoreAndTextModel, TrackingTokenizationStateStore } from './textModelTokens.js';
+import { AbstractTokens, AttachedViewHandler } from './tokens.js';
+import { TreeSitterTokens } from './treeSitterTokens.js';
+import { ITreeSitterParserService } from '../services/treeSitterParserService.js';
+import { ContiguousMultilineTokensBuilder } from '../tokens/contiguousMultilineTokensBuilder.js';
+import { ContiguousTokensStore } from '../tokens/contiguousTokensStore.js';
+import { SparseTokensStore } from '../tokens/sparseTokensStore.js';
+let TokenizationTextModelPart = TokenizationTextModelPart_1 = class TokenizationTextModelPart extends TextModelPart {
+    constructor(_textModel, _bracketPairsTextModelPart, _languageId, _attachedViews, _languageService, _languageConfigurationService, _treeSitterService) {
+        super();
+        this._textModel = _textModel;
+        this._bracketPairsTextModelPart = _bracketPairsTextModelPart;
+        this._languageId = _languageId;
+        this._attachedViews = _attachedViews;
+        this._languageService = _languageService;
+        this._languageConfigurationService = _languageConfigurationService;
+        this._treeSitterService = _treeSitterService;
+        this._semanticTokens = new SparseTokensStore(this._languageService.languageIdCodec);
+        this._onDidChangeLanguage = this._register(new Emitter());
+        this.onDidChangeLanguage = this._onDidChangeLanguage.event;
+        this._onDidChangeLanguageConfiguration = this._register(new Emitter());
+        this.onDidChangeLanguageConfiguration = this._onDidChangeLanguageConfiguration.event;
+        this._onDidChangeTokens = this._register(new Emitter());
+        this.onDidChangeTokens = this._onDidChangeTokens.event;
+        this._tokensDisposables = this._register(new DisposableStore());
+        this._register(this._languageConfigurationService.onDidChange(e => {
+            if (e.affects(this._languageId)) {
+                this._onDidChangeLanguageConfiguration.fire({});
+            }
+        }));
+        // We just look at registry changes to determine whether to use tree sitter.
+        // This means that removing a language from the setting will not cause a switch to textmate and will require a reload.
+        // Adding a language to the setting will not need a reload, however.
+        this._register(Event.filter(TreeSitterTokenizationRegistry.onDidChange, (e) => e.changedLanguages.includes(this._languageId))(() => {
+            this.createPreferredTokenProvider();
+        }));
+        this.createPreferredTokenProvider();
+    }
+    createGrammarTokens() {
+        return this._register(new GrammarTokens(this._languageService.languageIdCodec, this._textModel, () => this._languageId, this._attachedViews));
+    }
+    createTreeSitterTokens() {
+        return this._register(new TreeSitterTokens(this._treeSitterService, this._languageService.languageIdCodec, this._textModel, () => this._languageId));
+    }
+    createTokens(useTreeSitter) {
+        const needsReset = this._tokens !== undefined;
+        this._tokens?.dispose();
+        this._tokens = useTreeSitter ? this.createTreeSitterTokens() : this.createGrammarTokens();
+        this._tokensDisposables.clear();
+        this._tokensDisposables.add(this._tokens.onDidChangeTokens(e => {
+            this._emitModelTokensChangedEvent(e);
+        }));
+        this._tokensDisposables.add(this._tokens.onDidChangeBackgroundTokenizationState(e => {
+            this._bracketPairsTextModelPart.handleDidChangeBackgroundTokenizationState();
+        }));
+        if (needsReset) {
+            // We need to reset the tokenization, as the new token provider otherwise won't have a chance to provide tokens until some action happens in the editor.
+            this._tokens.resetTokenization();
+        }
+    }
+    createPreferredTokenProvider() {
+        if (TreeSitterTokenizationRegistry.get(this._languageId)) {
+            if (!(this._tokens instanceof TreeSitterTokens)) {
+                this.createTokens(true);
+            }
+        }
+        else {
+            if (!(this._tokens instanceof GrammarTokens)) {
+                this.createTokens(false);
+            }
+        }
+    }
+    handleLanguageConfigurationServiceChange(e) {
+        if (e.affects(this._languageId)) {
+            this._onDidChangeLanguageConfiguration.fire({});
+        }
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            this._semanticTokens.flush();
+        }
+        else if (!e.isEolChange) { // We don't have to do anything on an EOL change
+            for (const c of e.changes) {
+                const [eolCount, firstLineLength, lastLineLength] = countEOL(c.text);
+                this._semanticTokens.acceptEdit(c.range, eolCount, firstLineLength, lastLineLength, c.text.length > 0 ? c.text.charCodeAt(0) : 0 /* CharCode.Null */);
+            }
+        }
+        this._tokens.handleDidChangeContent(e);
+    }
+    handleDidChangeAttached() {
+        this._tokens.handleDidChangeAttached();
+    }
+    /**
+     * Includes grammar and semantic tokens.
+     */
+    getLineTokens(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        const syntacticTokens = this._tokens.getLineTokens(lineNumber);
+        return this._semanticTokens.addSparseTokens(lineNumber, syntacticTokens);
+    }
+    _emitModelTokensChangedEvent(e) {
+        if (!this._textModel._isDisposing()) {
+            this._bracketPairsTextModelPart.handleDidChangeTokens(e);
+            this._onDidChangeTokens.fire(e);
+        }
+    }
+    // #region Grammar Tokens
+    validateLineNumber(lineNumber) {
+        if (lineNumber < 1 || lineNumber > this._textModel.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+    }
+    get hasTokens() {
+        return this._tokens.hasTokens;
+    }
+    resetTokenization() {
+        this._tokens.resetTokenization();
+    }
+    get backgroundTokenizationState() {
+        return this._tokens.backgroundTokenizationState;
+    }
+    forceTokenization(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        this._tokens.forceTokenization(lineNumber);
+    }
+    hasAccurateTokensForLine(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        return this._tokens.hasAccurateTokensForLine(lineNumber);
+    }
+    isCheapToTokenize(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        return this._tokens.isCheapToTokenize(lineNumber);
+    }
+    tokenizeIfCheap(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        this._tokens.tokenizeIfCheap(lineNumber);
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        return this._tokens.getTokenTypeIfInsertingCharacter(lineNumber, column, character);
+    }
+    tokenizeLineWithEdit(position, length, newText) {
+        return this._tokens.tokenizeLineWithEdit(position, length, newText);
+    }
+    // #endregion
+    // #region Semantic Tokens
+    setSemanticTokens(tokens, isComplete) {
+        this._semanticTokens.set(tokens, isComplete);
+        this._emitModelTokensChangedEvent({
+            semanticTokensApplied: tokens !== null,
+            ranges: [{ fromLineNumber: 1, toLineNumber: this._textModel.getLineCount() }],
+        });
+    }
+    hasCompleteSemanticTokens() {
+        return this._semanticTokens.isComplete();
+    }
+    hasSomeSemanticTokens() {
+        return !this._semanticTokens.isEmpty();
+    }
+    setPartialSemanticTokens(range, tokens) {
+        if (this.hasCompleteSemanticTokens()) {
+            return;
+        }
+        const changedRange = this._textModel.validateRange(this._semanticTokens.setPartial(range, tokens));
+        this._emitModelTokensChangedEvent({
+            semanticTokensApplied: true,
+            ranges: [
+                {
+                    fromLineNumber: changedRange.startLineNumber,
+                    toLineNumber: changedRange.endLineNumber,
+                },
+            ],
+        });
+    }
+    // #endregion
+    // #region Utility Methods
+    getWordAtPosition(_position) {
+        this.assertNotDisposed();
+        const position = this._textModel.validatePosition(_position);
+        const lineContent = this._textModel.getLineContent(position.lineNumber);
+        const lineTokens = this.getLineTokens(position.lineNumber);
+        const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);
+        // (1). First try checking right biased word
+        const [rbStartOffset, rbEndOffset] = TokenizationTextModelPart_1._findLanguageBoundaries(lineTokens, tokenIndex);
+        const rightBiasedWord = getWordAtText(position.column, this.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex)).getWordDefinition(), lineContent.substring(rbStartOffset, rbEndOffset), rbStartOffset);
+        // Make sure the result touches the original passed in position
+        if (rightBiasedWord &&
+            rightBiasedWord.startColumn <= _position.column &&
+            _position.column <= rightBiasedWord.endColumn) {
+            return rightBiasedWord;
+        }
+        // (2). Else, if we were at a language boundary, check the left biased word
+        if (tokenIndex > 0 && rbStartOffset === position.column - 1) {
+            // edge case, where `position` sits between two tokens belonging to two different languages
+            const [lbStartOffset, lbEndOffset] = TokenizationTextModelPart_1._findLanguageBoundaries(lineTokens, tokenIndex - 1);
+            const leftBiasedWord = getWordAtText(position.column, this.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex - 1)).getWordDefinition(), lineContent.substring(lbStartOffset, lbEndOffset), lbStartOffset);
+            // Make sure the result touches the original passed in position
+            if (leftBiasedWord &&
+                leftBiasedWord.startColumn <= _position.column &&
+                _position.column <= leftBiasedWord.endColumn) {
+                return leftBiasedWord;
+            }
+        }
+        return null;
+    }
+    getLanguageConfiguration(languageId) {
+        return this._languageConfigurationService.getLanguageConfiguration(languageId);
+    }
+    static _findLanguageBoundaries(lineTokens, tokenIndex) {
+        const languageId = lineTokens.getLanguageId(tokenIndex);
+        // go left until a different language is hit
+        let startOffset = 0;
+        for (let i = tokenIndex; i >= 0 && lineTokens.getLanguageId(i) === languageId; i--) {
+            startOffset = lineTokens.getStartOffset(i);
+        }
+        // go right until a different language is hit
+        let endOffset = lineTokens.getLineContent().length;
+        for (let i = tokenIndex, tokenCount = lineTokens.getCount(); i < tokenCount && lineTokens.getLanguageId(i) === languageId; i++) {
+            endOffset = lineTokens.getEndOffset(i);
+        }
+        return [startOffset, endOffset];
+    }
+    getWordUntilPosition(position) {
+        const wordAtPosition = this.getWordAtPosition(position);
+        if (!wordAtPosition) {
+            return { word: '', startColumn: position.column, endColumn: position.column, };
+        }
+        return {
+            word: wordAtPosition.word.substr(0, position.column - wordAtPosition.startColumn),
+            startColumn: wordAtPosition.startColumn,
+            endColumn: position.column,
+        };
+    }
+    // #endregion
+    // #region Language Id handling
+    getLanguageId() {
+        return this._languageId;
+    }
+    getLanguageIdAtPosition(lineNumber, column) {
+        const position = this._textModel.validatePosition(new Position(lineNumber, column));
+        const lineTokens = this.getLineTokens(position.lineNumber);
+        return lineTokens.getLanguageId(lineTokens.findTokenIndexAtOffset(position.column - 1));
+    }
+    setLanguageId(languageId, source = 'api') {
+        if (this._languageId === languageId) {
+            // There's nothing to do
+            return;
+        }
+        const e = {
+            oldLanguage: this._languageId,
+            newLanguage: languageId,
+            source
+        };
+        this._languageId = languageId;
+        this._bracketPairsTextModelPart.handleDidChangeLanguage(e);
+        this._tokens.resetTokenization();
+        this.createPreferredTokenProvider();
+        this._onDidChangeLanguage.fire(e);
+        this._onDidChangeLanguageConfiguration.fire({});
+    }
+};
+TokenizationTextModelPart = TokenizationTextModelPart_1 = __decorate([
+    __param(4, ILanguageService),
+    __param(5, ILanguageConfigurationService),
+    __param(6, ITreeSitterParserService)
+], TokenizationTextModelPart);
+export { TokenizationTextModelPart };
+class GrammarTokens extends AbstractTokens {
+    constructor(languageIdCodec, textModel, getLanguageId, attachedViews) {
+        super(languageIdCodec, textModel, getLanguageId);
+        this._tokenizer = null;
+        this._defaultBackgroundTokenizer = null;
+        this._backgroundTokenizer = this._register(new MutableDisposable());
+        this._tokens = new ContiguousTokensStore(this._languageIdCodec);
+        this._debugBackgroundTokenizer = this._register(new MutableDisposable());
+        this._attachedViewStates = this._register(new DisposableMap());
+        this._register(TokenizationRegistry.onDidChange((e) => {
+            const languageId = this.getLanguageId();
+            if (e.changedLanguages.indexOf(languageId) === -1) {
+                return;
+            }
+            this.resetTokenization();
+        }));
+        this.resetTokenization();
+        this._register(attachedViews.onDidChangeVisibleRanges(({ view, state }) => {
+            if (state) {
+                let existing = this._attachedViewStates.get(view);
+                if (!existing) {
+                    existing = new AttachedViewHandler(() => this.refreshRanges(existing.lineRanges));
+                    this._attachedViewStates.set(view, existing);
+                }
+                existing.handleStateChange(state);
+            }
+            else {
+                this._attachedViewStates.deleteAndDispose(view);
+            }
+        }));
+    }
+    resetTokenization(fireTokenChangeEvent = true) {
+        this._tokens.flush();
+        this._debugBackgroundTokens?.flush();
+        if (this._debugBackgroundStates) {
+            this._debugBackgroundStates = new TrackingTokenizationStateStore(this._textModel.getLineCount());
+        }
+        if (fireTokenChangeEvent) {
+            this._onDidChangeTokens.fire({
+                semanticTokensApplied: false,
+                ranges: [
+                    {
+                        fromLineNumber: 1,
+                        toLineNumber: this._textModel.getLineCount(),
+                    },
+                ],
+            });
+        }
+        const initializeTokenization = () => {
+            if (this._textModel.isTooLargeForTokenization()) {
+                return [null, null];
+            }
+            const tokenizationSupport = TokenizationRegistry.get(this.getLanguageId());
+            if (!tokenizationSupport) {
+                return [null, null];
+            }
+            let initialState;
+            try {
+                initialState = tokenizationSupport.getInitialState();
+            }
+            catch (e) {
+                onUnexpectedError(e);
+                return [null, null];
+            }
+            return [tokenizationSupport, initialState];
+        };
+        const [tokenizationSupport, initialState] = initializeTokenization();
+        if (tokenizationSupport && initialState) {
+            this._tokenizer = new TokenizerWithStateStoreAndTextModel(this._textModel.getLineCount(), tokenizationSupport, this._textModel, this._languageIdCodec);
+        }
+        else {
+            this._tokenizer = null;
+        }
+        this._backgroundTokenizer.clear();
+        this._defaultBackgroundTokenizer = null;
+        if (this._tokenizer) {
+            const b = {
+                setTokens: (tokens) => {
+                    this.setTokens(tokens);
+                },
+                backgroundTokenizationFinished: () => {
+                    if (this._backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {
+                        // We already did a full tokenization and don't go back to progressing.
+                        return;
+                    }
+                    const newState = 2 /* BackgroundTokenizationState.Completed */;
+                    this._backgroundTokenizationState = newState;
+                    this._onDidChangeBackgroundTokenizationState.fire();
+                },
+                setEndState: (lineNumber, state) => {
+                    if (!this._tokenizer) {
+                        return;
+                    }
+                    const firstInvalidEndStateLineNumber = this._tokenizer.store.getFirstInvalidEndStateLineNumber();
+                    // Don't accept states for definitely valid states, the renderer is ahead of the worker!
+                    if (firstInvalidEndStateLineNumber !== null && lineNumber >= firstInvalidEndStateLineNumber) {
+                        this._tokenizer?.store.setEndState(lineNumber, state);
+                    }
+                },
+            };
+            if (tokenizationSupport && tokenizationSupport.createBackgroundTokenizer && !tokenizationSupport.backgroundTokenizerShouldOnlyVerifyTokens) {
+                this._backgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, b);
+            }
+            if (!this._backgroundTokenizer.value && !this._textModel.isTooLargeForTokenization()) {
+                this._backgroundTokenizer.value = this._defaultBackgroundTokenizer =
+                    new DefaultBackgroundTokenizer(this._tokenizer, b);
+                this._defaultBackgroundTokenizer.handleChanges();
+            }
+            if (tokenizationSupport?.backgroundTokenizerShouldOnlyVerifyTokens && tokenizationSupport.createBackgroundTokenizer) {
+                this._debugBackgroundTokens = new ContiguousTokensStore(this._languageIdCodec);
+                this._debugBackgroundStates = new TrackingTokenizationStateStore(this._textModel.getLineCount());
+                this._debugBackgroundTokenizer.clear();
+                this._debugBackgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, {
+                    setTokens: (tokens) => {
+                        this._debugBackgroundTokens?.setMultilineTokens(tokens, this._textModel);
+                    },
+                    backgroundTokenizationFinished() {
+                        // NO OP
+                    },
+                    setEndState: (lineNumber, state) => {
+                        this._debugBackgroundStates?.setEndState(lineNumber, state);
+                    },
+                });
+            }
+            else {
+                this._debugBackgroundTokens = undefined;
+                this._debugBackgroundStates = undefined;
+                this._debugBackgroundTokenizer.value = undefined;
+            }
+        }
+        this.refreshAllVisibleLineTokens();
+    }
+    handleDidChangeAttached() {
+        this._defaultBackgroundTokenizer?.handleChanges();
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            // Don't fire the event, as the view might not have got the text change event yet
+            this.resetTokenization(false);
+        }
+        else if (!e.isEolChange) { // We don't have to do anything on an EOL change
+            for (const c of e.changes) {
+                const [eolCount, firstLineLength] = countEOL(c.text);
+                this._tokens.acceptEdit(c.range, eolCount, firstLineLength);
+                this._debugBackgroundTokens?.acceptEdit(c.range, eolCount, firstLineLength);
+            }
+            this._debugBackgroundStates?.acceptChanges(e.changes);
+            if (this._tokenizer) {
+                this._tokenizer.store.acceptChanges(e.changes);
+            }
+            this._defaultBackgroundTokenizer?.handleChanges();
+        }
+    }
+    setTokens(tokens) {
+        const { changes } = this._tokens.setMultilineTokens(tokens, this._textModel);
+        if (changes.length > 0) {
+            this._onDidChangeTokens.fire({ semanticTokensApplied: false, ranges: changes, });
+        }
+        return { changes: changes };
+    }
+    refreshAllVisibleLineTokens() {
+        const ranges = LineRange.joinMany([...this._attachedViewStates].map(([_, s]) => s.lineRanges));
+        this.refreshRanges(ranges);
+    }
+    refreshRanges(ranges) {
+        for (const range of ranges) {
+            this.refreshRange(range.startLineNumber, range.endLineNumberExclusive - 1);
+        }
+    }
+    refreshRange(startLineNumber, endLineNumber) {
+        if (!this._tokenizer) {
+            return;
+        }
+        startLineNumber = Math.max(1, Math.min(this._textModel.getLineCount(), startLineNumber));
+        endLineNumber = Math.min(this._textModel.getLineCount(), endLineNumber);
+        const builder = new ContiguousMultilineTokensBuilder();
+        const { heuristicTokens } = this._tokenizer.tokenizeHeuristically(builder, startLineNumber, endLineNumber);
+        const changedTokens = this.setTokens(builder.finalize());
+        if (heuristicTokens) {
+            // We overrode tokens with heuristically computed ones.
+            // Because old states might get reused (thus stopping invalidation),
+            // we have to explicitly request the tokens for the changed ranges again.
+            for (const c of changedTokens.changes) {
+                this._backgroundTokenizer.value?.requestTokens(c.fromLineNumber, c.toLineNumber + 1);
+            }
+        }
+        this._defaultBackgroundTokenizer?.checkFinished();
+    }
+    forceTokenization(lineNumber) {
+        const builder = new ContiguousMultilineTokensBuilder();
+        this._tokenizer?.updateTokensUntilLine(builder, lineNumber);
+        this.setTokens(builder.finalize());
+        this._defaultBackgroundTokenizer?.checkFinished();
+    }
+    hasAccurateTokensForLine(lineNumber) {
+        if (!this._tokenizer) {
+            return true;
+        }
+        return this._tokenizer.hasAccurateTokensForLine(lineNumber);
+    }
+    isCheapToTokenize(lineNumber) {
+        if (!this._tokenizer) {
+            return true;
+        }
+        return this._tokenizer.isCheapToTokenize(lineNumber);
+    }
+    getLineTokens(lineNumber) {
+        const lineText = this._textModel.getLineContent(lineNumber);
+        const result = this._tokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);
+        if (this._debugBackgroundTokens && this._debugBackgroundStates && this._tokenizer) {
+            if (this._debugBackgroundStates.getFirstInvalidEndStateLineNumberOrMax() > lineNumber && this._tokenizer.store.getFirstInvalidEndStateLineNumberOrMax() > lineNumber) {
+                const backgroundResult = this._debugBackgroundTokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);
+                if (!result.equals(backgroundResult) && this._debugBackgroundTokenizer.value?.reportMismatchingTokens) {
+                    this._debugBackgroundTokenizer.value.reportMismatchingTokens(lineNumber);
+                }
+            }
+        }
+        return result;
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        if (!this._tokenizer) {
+            return 0 /* StandardTokenType.Other */;
+        }
+        const position = this._textModel.validatePosition(new Position(lineNumber, column));
+        this.forceTokenization(position.lineNumber);
+        return this._tokenizer.getTokenTypeIfInsertingCharacter(position, character);
+    }
+    tokenizeLineWithEdit(position, length, newText) {
+        if (!this._tokenizer) {
+            return null;
+        }
+        const validatedPosition = this._textModel.validatePosition(position);
+        this.forceTokenization(validatedPosition.lineNumber);
+        return this._tokenizer.tokenizeLineWithEdit(validatedPosition, length, newText);
+    }
+    get hasTokens() {
+        return this._tokens.hasTokens;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/tokens.js

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { equals } from '../../../base/common/arrays.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { LineRange } from '../core/lineRange.js';
+/**
+ * @internal
+ */
+export class AttachedViews {
+    constructor() {
+        this._onDidChangeVisibleRanges = new Emitter();
+        this.onDidChangeVisibleRanges = this._onDidChangeVisibleRanges.event;
+        this._views = new Set();
+    }
+    attachView() {
+        const view = new AttachedViewImpl((state) => {
+            this._onDidChangeVisibleRanges.fire({ view, state });
+        });
+        this._views.add(view);
+        return view;
+    }
+    detachView(view) {
+        this._views.delete(view);
+        this._onDidChangeVisibleRanges.fire({ view, state: undefined });
+    }
+}
+class AttachedViewImpl {
+    constructor(handleStateChange) {
+        this.handleStateChange = handleStateChange;
+    }
+    setVisibleLines(visibleLines, stabilized) {
+        const visibleLineRanges = visibleLines.map((line) => new LineRange(line.startLineNumber, line.endLineNumber + 1));
+        this.handleStateChange({ visibleLineRanges, stabilized });
+    }
+}
+export class AttachedViewHandler extends Disposable {
+    get lineRanges() { return this._lineRanges; }
+    constructor(_refreshTokens) {
+        super();
+        this._refreshTokens = _refreshTokens;
+        this.runner = this._register(new RunOnceScheduler(() => this.update(), 50));
+        this._computedLineRanges = [];
+        this._lineRanges = [];
+    }
+    update() {
+        if (equals(this._computedLineRanges, this._lineRanges, (a, b) => a.equals(b))) {
+            return;
+        }
+        this._computedLineRanges = this._lineRanges;
+        this._refreshTokens();
+    }
+    handleStateChange(state) {
+        this._lineRanges = state.visibleLineRanges;
+        if (state.stabilized) {
+            this.runner.cancel();
+            this.update();
+        }
+        else {
+            this.runner.schedule();
+        }
+    }
+}
+export class AbstractTokens extends Disposable {
+    get backgroundTokenizationState() {
+        return this._backgroundTokenizationState;
+    }
+    constructor(_languageIdCodec, _textModel, getLanguageId) {
+        super();
+        this._languageIdCodec = _languageIdCodec;
+        this._textModel = _textModel;
+        this.getLanguageId = getLanguageId;
+        this._backgroundTokenizationState = 1 /* BackgroundTokenizationState.InProgress */;
+        this._onDidChangeBackgroundTokenizationState = this._register(new Emitter());
+        /** @internal, should not be exposed by the text model! */
+        this.onDidChangeBackgroundTokenizationState = this._onDidChangeBackgroundTokenizationState.event;
+        this._onDidChangeTokens = this._register(new Emitter());
+        /** @internal, should not be exposed by the text model! */
+        this.onDidChangeTokens = this._onDidChangeTokens.event;
+    }
+    tokenizeIfCheap(lineNumber) {
+        if (this.isCheapToTokenize(lineNumber)) {
+            this.forceTokenization(lineNumber);
+        }
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/treeSitterTokens.js

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { TreeSitterTokenizationRegistry } from '../languages.js';
+import { LineTokens } from '../tokens/lineTokens.js';
+import { AbstractTokens } from './tokens.js';
+export class TreeSitterTokens extends AbstractTokens {
+    constructor(_treeSitterService, languageIdCodec, textModel, languageId) {
+        super(languageIdCodec, textModel, languageId);
+        this._treeSitterService = _treeSitterService;
+        this._tokenizationSupport = null;
+        this._initialize();
+    }
+    _initialize() {
+        const newLanguage = this.getLanguageId();
+        if (!this._tokenizationSupport || this._lastLanguageId !== newLanguage) {
+            this._lastLanguageId = newLanguage;
+            this._tokenizationSupport = TreeSitterTokenizationRegistry.get(newLanguage);
+        }
+    }
+    getLineTokens(lineNumber) {
+        const content = this._textModel.getLineContent(lineNumber);
+        if (this._tokenizationSupport) {
+            const rawTokens = this._tokenizationSupport.tokenizeEncoded(lineNumber, this._textModel);
+            if (rawTokens) {
+                return new LineTokens(rawTokens, content, this._languageIdCodec);
+            }
+        }
+        return LineTokens.createEmpty(content, this._languageIdCodec);
+    }
+    resetTokenization(fireTokenChangeEvent = true) {
+        if (fireTokenChangeEvent) {
+            this._onDidChangeTokens.fire({
+                semanticTokensApplied: false,
+                ranges: [
+                    {
+                        fromLineNumber: 1,
+                        toLineNumber: this._textModel.getLineCount(),
+                    },
+                ],
+            });
+        }
+        this._initialize();
+    }
+    handleDidChangeAttached() {
+        // TODO @alexr00 implement for background tokenization
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            // Don't fire the event, as the view might not have got the text change event yet
+            this.resetTokenization(false);
+        }
+    }
+    forceTokenization(lineNumber) {
+        // TODO @alexr00 implement
+    }
+    hasAccurateTokensForLine(lineNumber) {
+        // TODO @alexr00 update for background tokenization
+        return true;
+    }
+    isCheapToTokenize(lineNumber) {
+        // TODO @alexr00 update for background tokenization
+        return true;
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        // TODO @alexr00 implement once we have custom parsing and don't just feed in the whole text model value
+        return 0 /* StandardTokenType.Other */;
+    }
+    tokenizeLineWithEdit(position, length, newText) {
+        // TODO @alexr00 understand what this is for and implement
+        return null;
+    }
+    get hasTokens() {
+        // TODO @alexr00 once we have a token store, implement properly
+        const hasTree = this._treeSitterService.getParseResult(this._textModel) !== undefined;
+        return hasTree;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/model/utils.js

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Returns:
+ *  - -1 => the line consists of whitespace
+ *  - otherwise => the indent level is returned value
+ */
+export function computeIndentLevel(line, tabSize) {
+    let indent = 0;
+    let i = 0;
+    const len = line.length;
+    while (i < len) {
+        const chCode = line.charCodeAt(i);
+        if (chCode === 32 /* CharCode.Space */) {
+            indent++;
+        }
+        else if (chCode === 9 /* CharCode.Tab */) {
+            indent = indent - indent % tabSize + tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    if (i === len) {
+        return -1; // line only consists of whitespace
+    }
+    return indent;
+}

node_modules/monaco-editor/esm/vs/editor/common/modelLineProjectionData.js

@@ -0,0 +1,299 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { assertNever } from '../../base/common/assert.js';
+import { Position } from './core/position.js';
+import { InjectedTextCursorStops } from './model.js';
+/**
+ * *input*:
+ * ```
+ * xxxxxxxxxxxxxxxxxxxxxxxxxxx
+ * ```
+ *
+ * -> Applying injections `[i...i]`, *inputWithInjections*:
+ * ```
+ * xxxxxx[iiiiiiiiii]xxxxxxxxxxxxxxxxx[ii]xxxx
+ * ```
+ *
+ * -> breaking at offsets `|` in `xxxxxx[iiiiiii|iii]xxxxxxxxxxx|xxxxxx[ii]xxxx|`:
+ * ```
+ * xxxxxx[iiiiiii
+ * iii]xxxxxxxxxxx
+ * xxxxxx[ii]xxxx
+ * ```
+ *
+ * -> applying wrappedTextIndentLength, *output*:
+ * ```
+ * xxxxxx[iiiiiii
+ *    iii]xxxxxxxxxxx
+ *    xxxxxx[ii]xxxx
+ * ```
+ */
+export class ModelLineProjectionData {
+    constructor(injectionOffsets, 
+    /**
+     * `injectionOptions.length` must equal `injectionOffsets.length`
+     */
+    injectionOptions, 
+    /**
+     * Refers to offsets after applying injections to the source.
+     * The last break offset indicates the length of the source after applying injections.
+     */
+    breakOffsets, 
+    /**
+     * Refers to offsets after applying injections
+     */
+    breakOffsetsVisibleColumn, wrappedTextIndentLength) {
+        this.injectionOffsets = injectionOffsets;
+        this.injectionOptions = injectionOptions;
+        this.breakOffsets = breakOffsets;
+        this.breakOffsetsVisibleColumn = breakOffsetsVisibleColumn;
+        this.wrappedTextIndentLength = wrappedTextIndentLength;
+    }
+    getOutputLineCount() {
+        return this.breakOffsets.length;
+    }
+    getMinOutputOffset(outputLineIndex) {
+        if (outputLineIndex > 0) {
+            return this.wrappedTextIndentLength;
+        }
+        return 0;
+    }
+    getLineLength(outputLineIndex) {
+        // These offsets refer to model text with injected text.
+        const startOffset = outputLineIndex > 0 ? this.breakOffsets[outputLineIndex - 1] : 0;
+        const endOffset = this.breakOffsets[outputLineIndex];
+        let lineLength = endOffset - startOffset;
+        if (outputLineIndex > 0) {
+            lineLength += this.wrappedTextIndentLength;
+        }
+        return lineLength;
+    }
+    getMaxOutputOffset(outputLineIndex) {
+        return this.getLineLength(outputLineIndex);
+    }
+    translateToInputOffset(outputLineIndex, outputOffset) {
+        if (outputLineIndex > 0) {
+            outputOffset = Math.max(0, outputOffset - this.wrappedTextIndentLength);
+        }
+        const offsetInInputWithInjection = outputLineIndex === 0 ? outputOffset : this.breakOffsets[outputLineIndex - 1] + outputOffset;
+        let offsetInInput = offsetInInputWithInjection;
+        if (this.injectionOffsets !== null) {
+            for (let i = 0; i < this.injectionOffsets.length; i++) {
+                if (offsetInInput > this.injectionOffsets[i]) {
+                    if (offsetInInput < this.injectionOffsets[i] + this.injectionOptions[i].content.length) {
+                        // `inputOffset` is within injected text
+                        offsetInInput = this.injectionOffsets[i];
+                    }
+                    else {
+                        offsetInInput -= this.injectionOptions[i].content.length;
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        return offsetInInput;
+    }
+    translateToOutputPosition(inputOffset, affinity = 2 /* PositionAffinity.None */) {
+        let inputOffsetInInputWithInjection = inputOffset;
+        if (this.injectionOffsets !== null) {
+            for (let i = 0; i < this.injectionOffsets.length; i++) {
+                if (inputOffset < this.injectionOffsets[i]) {
+                    break;
+                }
+                if (affinity !== 1 /* PositionAffinity.Right */ && inputOffset === this.injectionOffsets[i]) {
+                    break;
+                }
+                inputOffsetInInputWithInjection += this.injectionOptions[i].content.length;
+            }
+        }
+        return this.offsetInInputWithInjectionsToOutputPosition(inputOffsetInInputWithInjection, affinity);
+    }
+    offsetInInputWithInjectionsToOutputPosition(offsetInInputWithInjections, affinity = 2 /* PositionAffinity.None */) {
+        let low = 0;
+        let high = this.breakOffsets.length - 1;
+        let mid = 0;
+        let midStart = 0;
+        while (low <= high) {
+            mid = low + ((high - low) / 2) | 0;
+            const midStop = this.breakOffsets[mid];
+            midStart = mid > 0 ? this.breakOffsets[mid - 1] : 0;
+            if (affinity === 0 /* PositionAffinity.Left */) {
+                if (offsetInInputWithInjections <= midStart) {
+                    high = mid - 1;
+                }
+                else if (offsetInInputWithInjections > midStop) {
+                    low = mid + 1;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                if (offsetInInputWithInjections < midStart) {
+                    high = mid - 1;
+                }
+                else if (offsetInInputWithInjections >= midStop) {
+                    low = mid + 1;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        let outputOffset = offsetInInputWithInjections - midStart;
+        if (mid > 0) {
+            outputOffset += this.wrappedTextIndentLength;
+        }
+        return new OutputPosition(mid, outputOffset);
+    }
+    normalizeOutputPosition(outputLineIndex, outputOffset, affinity) {
+        if (this.injectionOffsets !== null) {
+            const offsetInInputWithInjections = this.outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset);
+            const normalizedOffsetInUnwrappedLine = this.normalizeOffsetInInputWithInjectionsAroundInjections(offsetInInputWithInjections, affinity);
+            if (normalizedOffsetInUnwrappedLine !== offsetInInputWithInjections) {
+                // injected text caused a change
+                return this.offsetInInputWithInjectionsToOutputPosition(normalizedOffsetInUnwrappedLine, affinity);
+            }
+        }
+        if (affinity === 0 /* PositionAffinity.Left */) {
+            if (outputLineIndex > 0 && outputOffset === this.getMinOutputOffset(outputLineIndex)) {
+                return new OutputPosition(outputLineIndex - 1, this.getMaxOutputOffset(outputLineIndex - 1));
+            }
+        }
+        else if (affinity === 1 /* PositionAffinity.Right */) {
+            const maxOutputLineIndex = this.getOutputLineCount() - 1;
+            if (outputLineIndex < maxOutputLineIndex && outputOffset === this.getMaxOutputOffset(outputLineIndex)) {
+                return new OutputPosition(outputLineIndex + 1, this.getMinOutputOffset(outputLineIndex + 1));
+            }
+        }
+        return new OutputPosition(outputLineIndex, outputOffset);
+    }
+    outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset) {
+        if (outputLineIndex > 0) {
+            outputOffset = Math.max(0, outputOffset - this.wrappedTextIndentLength);
+        }
+        const result = (outputLineIndex > 0 ? this.breakOffsets[outputLineIndex - 1] : 0) + outputOffset;
+        return result;
+    }
+    normalizeOffsetInInputWithInjectionsAroundInjections(offsetInInputWithInjections, affinity) {
+        const injectedText = this.getInjectedTextAtOffset(offsetInInputWithInjections);
+        if (!injectedText) {
+            return offsetInInputWithInjections;
+        }
+        if (affinity === 2 /* PositionAffinity.None */) {
+            if (offsetInInputWithInjections === injectedText.offsetInInputWithInjections + injectedText.length
+                && hasRightCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {
+                return injectedText.offsetInInputWithInjections + injectedText.length;
+            }
+            else {
+                let result = injectedText.offsetInInputWithInjections;
+                if (hasLeftCursorStop(this.injectionOptions[injectedText.injectedTextIndex].cursorStops)) {
+                    return result;
+                }
+                let index = injectedText.injectedTextIndex - 1;
+                while (index >= 0 && this.injectionOffsets[index] === this.injectionOffsets[injectedText.injectedTextIndex]) {
+                    if (hasRightCursorStop(this.injectionOptions[index].cursorStops)) {
+                        break;
+                    }
+                    result -= this.injectionOptions[index].content.length;
+                    if (hasLeftCursorStop(this.injectionOptions[index].cursorStops)) {
+                        break;
+                    }
+                    index--;
+                }
+                return result;
+            }
+        }
+        else if (affinity === 1 /* PositionAffinity.Right */ || affinity === 4 /* PositionAffinity.RightOfInjectedText */) {
+            let result = injectedText.offsetInInputWithInjections + injectedText.length;
+            let index = injectedText.injectedTextIndex;
+            // traverse all injected text that touch each other
+            while (index + 1 < this.injectionOffsets.length && this.injectionOffsets[index + 1] === this.injectionOffsets[index]) {
+                result += this.injectionOptions[index + 1].content.length;
+                index++;
+            }
+            return result;
+        }
+        else if (affinity === 0 /* PositionAffinity.Left */ || affinity === 3 /* PositionAffinity.LeftOfInjectedText */) {
+            // affinity is left
+            let result = injectedText.offsetInInputWithInjections;
+            let index = injectedText.injectedTextIndex;
+            // traverse all injected text that touch each other
+            while (index - 1 >= 0 && this.injectionOffsets[index - 1] === this.injectionOffsets[index]) {
+                result -= this.injectionOptions[index - 1].content.length;
+                index--;
+            }
+            return result;
+        }
+        assertNever(affinity);
+    }
+    getInjectedText(outputLineIndex, outputOffset) {
+        const offset = this.outputPositionToOffsetInInputWithInjections(outputLineIndex, outputOffset);
+        const injectedText = this.getInjectedTextAtOffset(offset);
+        if (!injectedText) {
+            return null;
+        }
+        return {
+            options: this.injectionOptions[injectedText.injectedTextIndex]
+        };
+    }
+    getInjectedTextAtOffset(offsetInInputWithInjections) {
+        const injectionOffsets = this.injectionOffsets;
+        const injectionOptions = this.injectionOptions;
+        if (injectionOffsets !== null) {
+            let totalInjectedTextLengthBefore = 0;
+            for (let i = 0; i < injectionOffsets.length; i++) {
+                const length = injectionOptions[i].content.length;
+                const injectedTextStartOffsetInInputWithInjections = injectionOffsets[i] + totalInjectedTextLengthBefore;
+                const injectedTextEndOffsetInInputWithInjections = injectionOffsets[i] + totalInjectedTextLengthBefore + length;
+                if (injectedTextStartOffsetInInputWithInjections > offsetInInputWithInjections) {
+                    // Injected text starts later.
+                    break; // All later injected texts have an even larger offset.
+                }
+                if (offsetInInputWithInjections <= injectedTextEndOffsetInInputWithInjections) {
+                    // Injected text ends after or with the given position (but also starts with or before it).
+                    return {
+                        injectedTextIndex: i,
+                        offsetInInputWithInjections: injectedTextStartOffsetInInputWithInjections,
+                        length
+                    };
+                }
+                totalInjectedTextLengthBefore += length;
+            }
+        }
+        return undefined;
+    }
+}
+function hasRightCursorStop(cursorStop) {
+    if (cursorStop === null || cursorStop === undefined) {
+        return true;
+    }
+    return cursorStop === InjectedTextCursorStops.Right || cursorStop === InjectedTextCursorStops.Both;
+}
+function hasLeftCursorStop(cursorStop) {
+    if (cursorStop === null || cursorStop === undefined) {
+        return true;
+    }
+    return cursorStop === InjectedTextCursorStops.Left || cursorStop === InjectedTextCursorStops.Both;
+}
+export class InjectedText {
+    constructor(options) {
+        this.options = options;
+    }
+}
+export class OutputPosition {
+    constructor(outputLineIndex, outputOffset) {
+        this.outputLineIndex = outputLineIndex;
+        this.outputOffset = outputOffset;
+    }
+    toString() {
+        return `${this.outputLineIndex}:${this.outputOffset}`;
+    }
+    toPosition(baseLineNumber) {
+        return new Position(baseLineNumber + this.outputLineIndex, this.outputOffset + 1);
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/editorBaseApi.js

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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 * as standaloneEnums from '../standalone/standaloneEnums.js';
+export 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);
+    }
+}
+export function createMonacoBaseAPI() {
+    return {
+        editor: undefined, // undefined override expected here
+        languages: undefined, // undefined override expected here
+        CancellationTokenSource: CancellationTokenSource,
+        Emitter: Emitter,
+        KeyCode: standaloneEnums.KeyCode,
+        KeyMod: KeyMod,
+        Position: Position,
+        Range: Range,
+        Selection: Selection,
+        SelectionDirection: standaloneEnums.SelectionDirection,
+        MarkerSeverity: standaloneEnums.MarkerSeverity,
+        MarkerTag: standaloneEnums.MarkerTag,
+        Uri: URI,
+        Token: Token
+    };
+}

node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js

@@ -0,0 +1,351 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { stringDiff } from '../../../base/common/diff/diff.js';
+import { Range } from '../core/range.js';
+import { computeLinks } from '../languages/linkComputer.js';
+import { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';
+import { createMonacoBaseAPI } from './editorBaseApi.js';
+import { EditorWorkerHost } from './editorWorkerHost.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
+import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
+import { linesDiffComputers } from '../diff/linesDiffComputers.js';
+import { createProxyObject, getAllMethodNames } from '../../../base/common/objects.js';
+import { FileAccess } from '../../../base/common/network.js';
+import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
+import { findSectionHeaders } from './findSectionHeaders.js';
+import { WorkerTextModelSyncServer } from './textModelSync/textModelSync.impl.js';
+// ESM-comment-begin
+// const isESM = false;
+// ESM-comment-end
+// ESM-uncomment-begin
+const isESM = true;
+/**
+ * @internal
+ */
+export class BaseEditorSimpleWorker {
+    constructor() {
+        this._workerTextModelSyncServer = new WorkerTextModelSyncServer();
+    }
+    dispose() {
+    }
+    _getModel(uri) {
+        return this._workerTextModelSyncServer.getModel(uri);
+    }
+    _getModels() {
+        return this._workerTextModelSyncServer.getModels();
+    }
+    $acceptNewModel(data) {
+        this._workerTextModelSyncServer.$acceptNewModel(data);
+    }
+    $acceptModelChanged(uri, e) {
+        this._workerTextModelSyncServer.$acceptModelChanged(uri, e);
+    }
+    $acceptRemovedModel(uri) {
+        this._workerTextModelSyncServer.$acceptRemovedModel(uri);
+    }
+    async $computeUnicodeHighlights(url, options, range) {
+        const model = this._getModel(url);
+        if (!model) {
+            return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };
+        }
+        return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);
+    }
+    async $findSectionHeaders(url, options) {
+        const model = this._getModel(url);
+        if (!model) {
+            return [];
+        }
+        return findSectionHeaders(model, options);
+    }
+    // ---- BEGIN diff --------------------------------------------------------------------------
+    async $computeDiff(originalUrl, modifiedUrl, options, algorithm) {
+        const original = this._getModel(originalUrl);
+        const modified = this._getModel(modifiedUrl);
+        if (!original || !modified) {
+            return null;
+        }
+        const result = EditorSimpleWorker.computeDiff(original, modified, options, algorithm);
+        return result;
+    }
+    static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {
+        const diffAlgorithm = algorithm === 'advanced' ? linesDiffComputers.getDefault() : linesDiffComputers.getLegacy();
+        const originalLines = originalTextModel.getLinesContent();
+        const modifiedLines = modifiedTextModel.getLinesContent();
+        const result = diffAlgorithm.computeDiff(originalLines, modifiedLines, options);
+        const identical = (result.changes.length > 0 ? false : this._modelsAreIdentical(originalTextModel, modifiedTextModel));
+        function getLineChanges(changes) {
+            return changes.map(m => ([m.original.startLineNumber, m.original.endLineNumberExclusive, m.modified.startLineNumber, m.modified.endLineNumberExclusive, m.innerChanges?.map(m => [
+                    m.originalRange.startLineNumber,
+                    m.originalRange.startColumn,
+                    m.originalRange.endLineNumber,
+                    m.originalRange.endColumn,
+                    m.modifiedRange.startLineNumber,
+                    m.modifiedRange.startColumn,
+                    m.modifiedRange.endLineNumber,
+                    m.modifiedRange.endColumn,
+                ])]));
+        }
+        return {
+            identical,
+            quitEarly: result.hitTimeout,
+            changes: getLineChanges(result.changes),
+            moves: result.moves.map(m => ([
+                m.lineRangeMapping.original.startLineNumber,
+                m.lineRangeMapping.original.endLineNumberExclusive,
+                m.lineRangeMapping.modified.startLineNumber,
+                m.lineRangeMapping.modified.endLineNumberExclusive,
+                getLineChanges(m.changes)
+            ])),
+        };
+    }
+    static _modelsAreIdentical(original, modified) {
+        const originalLineCount = original.getLineCount();
+        const modifiedLineCount = modified.getLineCount();
+        if (originalLineCount !== modifiedLineCount) {
+            return false;
+        }
+        for (let line = 1; line <= originalLineCount; line++) {
+            const originalLine = original.getLineContent(line);
+            const modifiedLine = modified.getLineContent(line);
+            if (originalLine !== modifiedLine) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // ---- END diff --------------------------------------------------------------------------
+    // ---- BEGIN minimal edits ---------------------------------------------------------------
+    static { this._diffLimit = 100000; }
+    async $computeMoreMinimalEdits(modelUrl, edits, pretty) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return edits;
+        }
+        const result = [];
+        let lastEol = undefined;
+        edits = edits.slice(0).sort((a, b) => {
+            if (a.range && b.range) {
+                return Range.compareRangesUsingStarts(a.range, b.range);
+            }
+            // eol only changes should go to the end
+            const aRng = a.range ? 0 : 1;
+            const bRng = b.range ? 0 : 1;
+            return aRng - bRng;
+        });
+        // merge adjacent edits
+        let writeIndex = 0;
+        for (let readIndex = 1; readIndex < edits.length; readIndex++) {
+            if (Range.getEndPosition(edits[writeIndex].range).equals(Range.getStartPosition(edits[readIndex].range))) {
+                edits[writeIndex].range = Range.fromPositions(Range.getStartPosition(edits[writeIndex].range), Range.getEndPosition(edits[readIndex].range));
+                edits[writeIndex].text += edits[readIndex].text;
+            }
+            else {
+                writeIndex++;
+                edits[writeIndex] = edits[readIndex];
+            }
+        }
+        edits.length = writeIndex + 1;
+        for (let { range, text, eol } of edits) {
+            if (typeof eol === 'number') {
+                lastEol = eol;
+            }
+            if (Range.isEmpty(range) && !text) {
+                // empty change
+                continue;
+            }
+            const original = model.getValueInRange(range);
+            text = text.replace(/\r\n|\n|\r/g, model.eol);
+            if (original === text) {
+                // noop
+                continue;
+            }
+            // make sure diff won't take too long
+            if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {
+                result.push({ range, text });
+                continue;
+            }
+            // compute diff between original and edit.text
+            const changes = stringDiff(original, text, pretty);
+            const editOffset = model.offsetAt(Range.lift(range).getStartPosition());
+            for (const change of changes) {
+                const start = model.positionAt(editOffset + change.originalStart);
+                const end = model.positionAt(editOffset + change.originalStart + change.originalLength);
+                const newEdit = {
+                    text: text.substr(change.modifiedStart, change.modifiedLength),
+                    range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }
+                };
+                if (model.getValueInRange(newEdit.range) !== newEdit.text) {
+                    result.push(newEdit);
+                }
+            }
+        }
+        if (typeof lastEol === 'number') {
+            result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });
+        }
+        return result;
+    }
+    // ---- END minimal edits ---------------------------------------------------------------
+    async $computeLinks(modelUrl) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        return computeLinks(model);
+    }
+    // --- BEGIN default document colors -----------------------------------------------------------
+    async $computeDefaultDocumentColors(modelUrl) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        return computeDefaultDocumentColors(model);
+    }
+    // ---- BEGIN suggest --------------------------------------------------------------------------
+    static { this._suggestionsLimit = 10000; }
+    async $textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
+        const sw = new StopWatch();
+        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
+        const seen = new Set();
+        outer: for (const url of modelUrls) {
+            const model = this._getModel(url);
+            if (!model) {
+                continue;
+            }
+            for (const word of model.words(wordDefRegExp)) {
+                if (word === leadingWord || !isNaN(Number(word))) {
+                    continue;
+                }
+                seen.add(word);
+                if (seen.size > EditorSimpleWorker._suggestionsLimit) {
+                    break outer;
+                }
+            }
+        }
+        return { words: Array.from(seen), duration: sw.elapsed() };
+    }
+    // ---- END suggest --------------------------------------------------------------------------
+    //#region -- word ranges --
+    async $computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return Object.create(null);
+        }
+        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
+        const result = Object.create(null);
+        for (let line = range.startLineNumber; line < range.endLineNumber; line++) {
+            const words = model.getLineWords(line, wordDefRegExp);
+            for (const word of words) {
+                if (!isNaN(Number(word.word))) {
+                    continue;
+                }
+                let array = result[word.word];
+                if (!array) {
+                    array = [];
+                    result[word.word] = array;
+                }
+                array.push({
+                    startLineNumber: line,
+                    startColumn: word.startColumn,
+                    endLineNumber: line,
+                    endColumn: word.endColumn
+                });
+            }
+        }
+        return result;
+    }
+    //#endregion
+    async $navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
+        const model = this._getModel(modelUrl);
+        if (!model) {
+            return null;
+        }
+        const wordDefRegExp = new RegExp(wordDef, wordDefFlags);
+        if (range.startColumn === range.endColumn) {
+            range = {
+                startLineNumber: range.startLineNumber,
+                startColumn: range.startColumn,
+                endLineNumber: range.endLineNumber,
+                endColumn: range.endColumn + 1
+            };
+        }
+        const selectionText = model.getValueInRange(range);
+        const wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);
+        if (!wordRange) {
+            return null;
+        }
+        const word = model.getValueInRange(wordRange);
+        const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export class EditorSimpleWorker extends BaseEditorSimpleWorker {
+    constructor(_host, _foreignModuleFactory) {
+        super();
+        this._host = _host;
+        this._foreignModuleFactory = _foreignModuleFactory;
+        this._foreignModule = null;
+    }
+    async $ping() {
+        return 'pong';
+    }
+    // ---- BEGIN foreign module support --------------------------------------------------------------------------
+    $loadForeignModule(moduleId, createData, foreignHostMethods) {
+        const proxyMethodRequest = (method, args) => {
+            return this._host.$fhr(method, args);
+        };
+        const foreignHost = createProxyObject(foreignHostMethods, proxyMethodRequest);
+        const ctx = {
+            host: foreignHost,
+            getMirrorModels: () => {
+                return this._getModels();
+            }
+        };
+        if (this._foreignModuleFactory) {
+            this._foreignModule = this._foreignModuleFactory(ctx, createData);
+            // static foreing module
+            return Promise.resolve(getAllMethodNames(this._foreignModule));
+        }
+        return new Promise((resolve, reject) => {
+            const onModuleCallback = (foreignModule) => {
+                this._foreignModule = foreignModule.create(ctx, createData);
+                resolve(getAllMethodNames(this._foreignModule));
+            };
+            if (!isESM) {
+                require([`${moduleId}`], onModuleCallback, reject);
+            }
+            else {
+                const url = FileAccess.asBrowserUri(`${moduleId}.js`).toString(true);
+                import(`${url}`).then(onModuleCallback).catch(reject);
+            }
+        });
+    }
+    // foreign method request
+    $fmr(method, args) {
+        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
+            return Promise.reject(new Error('Missing requestHandler or method: ' + method));
+        }
+        try {
+            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+}
+/**
+ * Defines the worker entry point. Must be exported and named `create`.
+ * @skipMangle
+ * @internal
+ */
+export function create(workerServer) {
+    return new EditorSimpleWorker(EditorWorkerHost.getChannel(workerServer), null);
+}
+if (typeof importScripts === 'function') {
+    // Running in a web worker
+    globalThis.monaco = createMonacoBaseAPI();
+}

node_modules/monaco-editor/esm/vs/editor/common/services/editorWorker.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+export const IEditorWorkerService = createDecorator('editorWorkerService');

node_modules/monaco-editor/esm/vs/editor/common/services/editorWorkerHost.js

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class EditorWorkerHost {
+    static { this.CHANNEL_NAME = 'editorWorkerHost'; }
+    static getChannel(workerServer) {
+        return workerServer.getChannel(EditorWorkerHost.CHANNEL_NAME);
+    }
+    static setChannel(workerClient, obj) {
+        workerClient.setChannel(EditorWorkerHost.CHANNEL_NAME, obj);
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/findSectionHeaders.js

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const markRegex = new RegExp('\\bMARK:\\s*(.*)$', 'd');
+const trimDashesRegex = /^-+|-+$/g;
+/**
+ * Find section headers in the model.
+ *
+ * @param model the text model to search in
+ * @param options options to search with
+ * @returns an array of section headers
+ */
+export function findSectionHeaders(model, options) {
+    let headers = [];
+    if (options.findRegionSectionHeaders && options.foldingRules?.markers) {
+        const regionHeaders = collectRegionHeaders(model, options);
+        headers = headers.concat(regionHeaders);
+    }
+    if (options.findMarkSectionHeaders) {
+        const markHeaders = collectMarkHeaders(model);
+        headers = headers.concat(markHeaders);
+    }
+    return headers;
+}
+function collectRegionHeaders(model, options) {
+    const regionHeaders = [];
+    const endLineNumber = model.getLineCount();
+    for (let lineNumber = 1; lineNumber <= endLineNumber; lineNumber++) {
+        const lineContent = model.getLineContent(lineNumber);
+        const match = lineContent.match(options.foldingRules.markers.start);
+        if (match) {
+            const range = { startLineNumber: lineNumber, startColumn: match[0].length + 1, endLineNumber: lineNumber, endColumn: lineContent.length + 1 };
+            if (range.endColumn > range.startColumn) {
+                const sectionHeader = {
+                    range,
+                    ...getHeaderText(lineContent.substring(match[0].length)),
+                    shouldBeInComments: false
+                };
+                if (sectionHeader.text || sectionHeader.hasSeparatorLine) {
+                    regionHeaders.push(sectionHeader);
+                }
+            }
+        }
+    }
+    return regionHeaders;
+}
+function collectMarkHeaders(model) {
+    const markHeaders = [];
+    const endLineNumber = model.getLineCount();
+    for (let lineNumber = 1; lineNumber <= endLineNumber; lineNumber++) {
+        const lineContent = model.getLineContent(lineNumber);
+        addMarkHeaderIfFound(lineContent, lineNumber, markHeaders);
+    }
+    return markHeaders;
+}
+function addMarkHeaderIfFound(lineContent, lineNumber, sectionHeaders) {
+    markRegex.lastIndex = 0;
+    const match = markRegex.exec(lineContent);
+    if (match) {
+        const column = match.indices[1][0] + 1;
+        const endColumn = match.indices[1][1] + 1;
+        const range = { startLineNumber: lineNumber, startColumn: column, endLineNumber: lineNumber, endColumn: endColumn };
+        if (range.endColumn > range.startColumn) {
+            const sectionHeader = {
+                range,
+                ...getHeaderText(match[1]),
+                shouldBeInComments: true
+            };
+            if (sectionHeader.text || sectionHeader.hasSeparatorLine) {
+                sectionHeaders.push(sectionHeader);
+            }
+        }
+    }
+}
+function getHeaderText(text) {
+    text = text.trim();
+    const hasSeparatorLine = text.startsWith('-');
+    text = text.replace(trimDashesRegex, '');
+    return { text, hasSeparatorLine };
+}

node_modules/monaco-editor/esm/vs/editor/common/services/getIconClasses.js

@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Schemas } from '../../../base/common/network.js';
+import { DataUri } from '../../../base/common/resources.js';
+import { URI } from '../../../base/common/uri.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { FileKind } from '../../../platform/files/common/files.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
+const fileIconDirectoryRegex = /(?:\/|^)(?:([^\/]+)\/)?([^\/]+)$/;
+export function getIconClasses(modelService, languageService, resource, fileKind, icon) {
+    if (ThemeIcon.isThemeIcon(icon)) {
+        return [`codicon-${icon.id}`, 'predefined-file-icon'];
+    }
+    if (URI.isUri(icon)) {
+        return [];
+    }
+    // we always set these base classes even if we do not have a path
+    const classes = fileKind === FileKind.ROOT_FOLDER ? ['rootfolder-icon'] : fileKind === FileKind.FOLDER ? ['folder-icon'] : ['file-icon'];
+    if (resource) {
+        // Get the path and name of the resource. For data-URIs, we need to parse specially
+        let name;
+        if (resource.scheme === Schemas.data) {
+            const metadata = DataUri.parseMetaData(resource);
+            name = metadata.get(DataUri.META_DATA_LABEL);
+        }
+        else {
+            const match = resource.path.match(fileIconDirectoryRegex);
+            if (match) {
+                name = cssEscape(match[2].toLowerCase());
+                if (match[1]) {
+                    classes.push(`${cssEscape(match[1].toLowerCase())}-name-dir-icon`); // parent directory
+                }
+            }
+            else {
+                name = cssEscape(resource.authority.toLowerCase());
+            }
+        }
+        // Root Folders
+        if (fileKind === FileKind.ROOT_FOLDER) {
+            classes.push(`${name}-root-name-folder-icon`);
+        }
+        // Folders
+        else if (fileKind === FileKind.FOLDER) {
+            classes.push(`${name}-name-folder-icon`);
+        }
+        // Files
+        else {
+            // Name & Extension(s)
+            if (name) {
+                classes.push(`${name}-name-file-icon`);
+                classes.push(`name-file-icon`); // extra segment to increase file-name score
+                // Avoid doing an explosive combination of extensions for very long filenames
+                // (most file systems do not allow files > 255 length) with lots of `.` characters
+                // https://github.com/microsoft/vscode/issues/116199
+                if (name.length <= 255) {
+                    const dotSegments = name.split('.');
+                    for (let i = 1; i < dotSegments.length; i++) {
+                        classes.push(`${dotSegments.slice(i).join('.')}-ext-file-icon`); // add each combination of all found extensions if more than one
+                    }
+                }
+                classes.push(`ext-file-icon`); // extra segment to increase file-ext score
+            }
+            // Detected Mode
+            const detectedLanguageId = detectLanguageId(modelService, languageService, resource);
+            if (detectedLanguageId) {
+                classes.push(`${cssEscape(detectedLanguageId)}-lang-file-icon`);
+            }
+        }
+    }
+    return classes;
+}
+function detectLanguageId(modelService, languageService, resource) {
+    if (!resource) {
+        return null; // we need a resource at least
+    }
+    let languageId = null;
+    // Data URI: check for encoded metadata
+    if (resource.scheme === Schemas.data) {
+        const metadata = DataUri.parseMetaData(resource);
+        const mime = metadata.get(DataUri.META_DATA_MIME);
+        if (mime) {
+            languageId = languageService.getLanguageIdByMimeType(mime);
+        }
+    }
+    // Any other URI: check for model if existing
+    else {
+        const model = modelService.getModel(resource);
+        if (model) {
+            languageId = model.getLanguageId();
+        }
+    }
+    // only take if the language id is specific (aka no just plain text)
+    if (languageId && languageId !== PLAINTEXT_LANGUAGE_ID) {
+        return languageId;
+    }
+    // otherwise fallback to path based detection
+    return languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+}
+function cssEscape(str) {
+    return str.replace(/[\s]/g, '/'); // HTML class names can not contain certain whitespace characters (https://dom.spec.whatwg.org/#interface-domtokenlist), use / instead, which doesn't exist in file names.
+}

node_modules/monaco-editor/esm/vs/editor/common/services/languageFeatureDebounce.js

@@ -0,0 +1,135 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { doHash } from '../../../base/common/hash.js';
+import { LRUCache } from '../../../base/common/map.js';
+import { clamp, MovingAverage, SlidingWindowAverage } from '../../../base/common/numbers.js';
+import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
+import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { matchesScheme } from '../../../base/common/network.js';
+export const ILanguageFeatureDebounceService = createDecorator('ILanguageFeatureDebounceService');
+var IdentityHash;
+(function (IdentityHash) {
+    const _hashes = new WeakMap();
+    let pool = 0;
+    function of(obj) {
+        let value = _hashes.get(obj);
+        if (value === undefined) {
+            value = ++pool;
+            _hashes.set(obj, value);
+        }
+        return value;
+    }
+    IdentityHash.of = of;
+})(IdentityHash || (IdentityHash = {}));
+class NullDebounceInformation {
+    constructor(_default) {
+        this._default = _default;
+    }
+    get(_model) {
+        return this._default;
+    }
+    update(_model, _value) {
+        return this._default;
+    }
+    default() {
+        return this._default;
+    }
+}
+class FeatureDebounceInformation {
+    constructor(_logService, _name, _registry, _default, _min, _max) {
+        this._logService = _logService;
+        this._name = _name;
+        this._registry = _registry;
+        this._default = _default;
+        this._min = _min;
+        this._max = _max;
+        this._cache = new LRUCache(50, 0.7);
+    }
+    _key(model) {
+        return model.id + this._registry.all(model).reduce((hashVal, obj) => doHash(IdentityHash.of(obj), hashVal), 0);
+    }
+    get(model) {
+        const key = this._key(model);
+        const avg = this._cache.get(key);
+        return avg
+            ? clamp(avg.value, this._min, this._max)
+            : this.default();
+    }
+    update(model, value) {
+        const key = this._key(model);
+        let avg = this._cache.get(key);
+        if (!avg) {
+            avg = new SlidingWindowAverage(6);
+            this._cache.set(key, avg);
+        }
+        const newValue = clamp(avg.update(value), this._min, this._max);
+        if (!matchesScheme(model.uri, 'output')) {
+            this._logService.trace(`[DEBOUNCE: ${this._name}] for ${model.uri.toString()} is ${newValue}ms`);
+        }
+        return newValue;
+    }
+    _overall() {
+        const result = new MovingAverage();
+        for (const [, avg] of this._cache) {
+            result.update(avg.value);
+        }
+        return result.value;
+    }
+    default() {
+        const value = (this._overall() | 0) || this._default;
+        return clamp(value, this._min, this._max);
+    }
+}
+let LanguageFeatureDebounceService = class LanguageFeatureDebounceService {
+    constructor(_logService, envService) {
+        this._logService = _logService;
+        this._data = new Map();
+        this._isDev = envService.isExtensionDevelopment || !envService.isBuilt;
+    }
+    for(feature, name, config) {
+        const min = config?.min ?? 50;
+        const max = config?.max ?? min ** 2;
+        const extra = config?.key ?? undefined;
+        const key = `${IdentityHash.of(feature)},${min}${extra ? ',' + extra : ''}`;
+        let info = this._data.get(key);
+        if (!info) {
+            if (this._isDev) {
+                this._logService.debug(`[DEBOUNCE: ${name}] is disabled in developed mode`);
+                info = new NullDebounceInformation(min * 1.5);
+            }
+            else {
+                info = new FeatureDebounceInformation(this._logService, name, feature, (this._overallAverage() | 0) || (min * 1.5), // default is overall default or derived from min-value
+                min, max);
+            }
+            this._data.set(key, info);
+        }
+        return info;
+    }
+    _overallAverage() {
+        // Average of all language features. Not a great value but an approximation
+        const result = new MovingAverage();
+        for (const info of this._data.values()) {
+            result.update(info.default());
+        }
+        return result.value;
+    }
+};
+LanguageFeatureDebounceService = __decorate([
+    __param(0, ILogService),
+    __param(1, IEnvironmentService)
+], LanguageFeatureDebounceService);
+export { LanguageFeatureDebounceService };
+registerSingleton(ILanguageFeatureDebounceService, LanguageFeatureDebounceService, 1 /* InstantiationType.Delayed */);

node_modules/monaco-editor/esm/vs/editor/common/services/languageFeatures.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+export const ILanguageFeaturesService = createDecorator('ILanguageFeaturesService');

node_modules/monaco-editor/esm/vs/editor/common/services/languageFeaturesService.js

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { LanguageFeatureRegistry } from '../languageFeatureRegistry.js';
+import { ILanguageFeaturesService } from './languageFeatures.js';
+import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+export class LanguageFeaturesService {
+    constructor() {
+        this.referenceProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.renameProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.newSymbolNamesProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.codeActionProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.definitionProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.typeDefinitionProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.declarationProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.implementationProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentSymbolProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.inlayHintsProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.colorProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.codeLensProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentFormattingEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentRangeFormattingEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.onTypeFormattingEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.signatureHelpProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.hoverProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentHighlightProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.multiDocumentHighlightProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.selectionRangeProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.foldingRangeProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.linkProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.inlineCompletionsProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.inlineEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.completionProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.linkedEditingRangeProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentRangeSemanticTokensProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentSemanticTokensProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentDropEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
+        this.documentPasteEditProvider = new LanguageFeatureRegistry(this._score.bind(this));
+    }
+    _score(uri) {
+        return this._notebookTypeResolver?.(uri);
+    }
+}
+registerSingleton(ILanguageFeaturesService, LanguageFeaturesService, 1 /* InstantiationType.Delayed */);

node_modules/monaco-editor/esm/vs/editor/common/services/languageService.js

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Emitter, Event } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { LanguagesRegistry } from './languagesRegistry.js';
+import { firstOrDefault } from '../../../base/common/arrays.js';
+import { TokenizationRegistry } from '../languages.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { observableFromEvent } from '../../../base/common/observable.js';
+export class LanguageService extends Disposable {
+    static { this.instanceCount = 0; }
+    constructor(warnOnOverwrite = false) {
+        super();
+        this._onDidRequestBasicLanguageFeatures = this._register(new Emitter());
+        this.onDidRequestBasicLanguageFeatures = this._onDidRequestBasicLanguageFeatures.event;
+        this._onDidRequestRichLanguageFeatures = this._register(new Emitter());
+        this.onDidRequestRichLanguageFeatures = this._onDidRequestRichLanguageFeatures.event;
+        this._onDidChange = this._register(new Emitter({ leakWarningThreshold: 200 /* https://github.com/microsoft/vscode/issues/119968 */ }));
+        this.onDidChange = this._onDidChange.event;
+        this._requestedBasicLanguages = new Set();
+        this._requestedRichLanguages = new Set();
+        LanguageService.instanceCount++;
+        this._registry = this._register(new LanguagesRegistry(true, warnOnOverwrite));
+        this.languageIdCodec = this._registry.languageIdCodec;
+        this._register(this._registry.onDidChange(() => this._onDidChange.fire()));
+    }
+    dispose() {
+        LanguageService.instanceCount--;
+        super.dispose();
+    }
+    isRegisteredLanguageId(languageId) {
+        return this._registry.isRegisteredLanguageId(languageId);
+    }
+    getLanguageIdByLanguageName(languageName) {
+        return this._registry.getLanguageIdByLanguageName(languageName);
+    }
+    getLanguageIdByMimeType(mimeType) {
+        return this._registry.getLanguageIdByMimeType(mimeType);
+    }
+    guessLanguageIdByFilepathOrFirstLine(resource, firstLine) {
+        const languageIds = this._registry.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
+        return firstOrDefault(languageIds, null);
+    }
+    createById(languageId) {
+        return new LanguageSelection(this.onDidChange, () => {
+            return this._createAndGetLanguageIdentifier(languageId);
+        });
+    }
+    createByFilepathOrFirstLine(resource, firstLine) {
+        return new LanguageSelection(this.onDidChange, () => {
+            const languageId = this.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
+            return this._createAndGetLanguageIdentifier(languageId);
+        });
+    }
+    _createAndGetLanguageIdentifier(languageId) {
+        if (!languageId || !this.isRegisteredLanguageId(languageId)) {
+            // Fall back to plain text if language is unknown
+            languageId = PLAINTEXT_LANGUAGE_ID;
+        }
+        return languageId;
+    }
+    requestBasicLanguageFeatures(languageId) {
+        if (!this._requestedBasicLanguages.has(languageId)) {
+            this._requestedBasicLanguages.add(languageId);
+            this._onDidRequestBasicLanguageFeatures.fire(languageId);
+        }
+    }
+    requestRichLanguageFeatures(languageId) {
+        if (!this._requestedRichLanguages.has(languageId)) {
+            this._requestedRichLanguages.add(languageId);
+            // Ensure basic features are requested
+            this.requestBasicLanguageFeatures(languageId);
+            // Ensure tokenizers are created
+            TokenizationRegistry.getOrCreate(languageId);
+            this._onDidRequestRichLanguageFeatures.fire(languageId);
+        }
+    }
+}
+class LanguageSelection {
+    constructor(onDidChangeLanguages, selector) {
+        this._value = observableFromEvent(this, onDidChangeLanguages, () => selector());
+        this.onDidChange = Event.fromObservable(this._value);
+    }
+    get languageId() {
+        return this._value.get();
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/languagesAssociations.js

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { parse } from '../../../base/common/glob.js';
+import { Mimes } from '../../../base/common/mime.js';
+import { Schemas } from '../../../base/common/network.js';
+import { basename, posix } from '../../../base/common/path.js';
+import { DataUri } from '../../../base/common/resources.js';
+import { startsWithUTF8BOM } from '../../../base/common/strings.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+let registeredAssociations = [];
+let nonUserRegisteredAssociations = [];
+let userRegisteredAssociations = [];
+/**
+ * Associate a language to the registry (platform).
+ * * **NOTE**: This association will lose over associations registered using `registerConfiguredLanguageAssociation`.
+ * * **NOTE**: Use `clearPlatformLanguageAssociations` to remove all associations registered using this function.
+ */
+export function registerPlatformLanguageAssociation(association, warnOnOverwrite = false) {
+    _registerLanguageAssociation(association, false, warnOnOverwrite);
+}
+function _registerLanguageAssociation(association, userConfigured, warnOnOverwrite) {
+    // Register
+    const associationItem = toLanguageAssociationItem(association, userConfigured);
+    registeredAssociations.push(associationItem);
+    if (!associationItem.userConfigured) {
+        nonUserRegisteredAssociations.push(associationItem);
+    }
+    else {
+        userRegisteredAssociations.push(associationItem);
+    }
+    // Check for conflicts unless this is a user configured association
+    if (warnOnOverwrite && !associationItem.userConfigured) {
+        registeredAssociations.forEach(a => {
+            if (a.mime === associationItem.mime || a.userConfigured) {
+                return; // same mime or userConfigured is ok
+            }
+            if (associationItem.extension && a.extension === associationItem.extension) {
+                console.warn(`Overwriting extension <<${associationItem.extension}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.filename && a.filename === associationItem.filename) {
+                console.warn(`Overwriting filename <<${associationItem.filename}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.filepattern && a.filepattern === associationItem.filepattern) {
+                console.warn(`Overwriting filepattern <<${associationItem.filepattern}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.firstline && a.firstline === associationItem.firstline) {
+                console.warn(`Overwriting firstline <<${associationItem.firstline}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+        });
+    }
+}
+function toLanguageAssociationItem(association, userConfigured) {
+    return {
+        id: association.id,
+        mime: association.mime,
+        filename: association.filename,
+        extension: association.extension,
+        filepattern: association.filepattern,
+        firstline: association.firstline,
+        userConfigured: userConfigured,
+        filenameLowercase: association.filename ? association.filename.toLowerCase() : undefined,
+        extensionLowercase: association.extension ? association.extension.toLowerCase() : undefined,
+        filepatternLowercase: association.filepattern ? parse(association.filepattern.toLowerCase()) : undefined,
+        filepatternOnPath: association.filepattern ? association.filepattern.indexOf(posix.sep) >= 0 : false
+    };
+}
+/**
+ * Clear language associations from the registry (platform).
+ */
+export function clearPlatformLanguageAssociations() {
+    registeredAssociations = registeredAssociations.filter(a => a.userConfigured);
+    nonUserRegisteredAssociations = [];
+}
+/**
+ * @see `getMimeTypes`
+ */
+export function getLanguageIds(resource, firstLine) {
+    return getAssociations(resource, firstLine).map(item => item.id);
+}
+function getAssociations(resource, firstLine) {
+    let path;
+    if (resource) {
+        switch (resource.scheme) {
+            case Schemas.file:
+                path = resource.fsPath;
+                break;
+            case Schemas.data: {
+                const metadata = DataUri.parseMetaData(resource);
+                path = metadata.get(DataUri.META_DATA_LABEL);
+                break;
+            }
+            case Schemas.vscodeNotebookCell:
+                // File path not relevant for language detection of cell
+                path = undefined;
+                break;
+            default:
+                path = resource.path;
+        }
+    }
+    if (!path) {
+        return [{ id: 'unknown', mime: Mimes.unknown }];
+    }
+    path = path.toLowerCase();
+    const filename = basename(path);
+    // 1.) User configured mappings have highest priority
+    const configuredLanguage = getAssociationByPath(path, filename, userRegisteredAssociations);
+    if (configuredLanguage) {
+        return [configuredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+    }
+    // 2.) Registered mappings have middle priority
+    const registeredLanguage = getAssociationByPath(path, filename, nonUserRegisteredAssociations);
+    if (registeredLanguage) {
+        return [registeredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+    }
+    // 3.) Firstline has lowest priority
+    if (firstLine) {
+        const firstlineLanguage = getAssociationByFirstline(firstLine);
+        if (firstlineLanguage) {
+            return [firstlineLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+        }
+    }
+    return [{ id: 'unknown', mime: Mimes.unknown }];
+}
+function getAssociationByPath(path, filename, associations) {
+    let filenameMatch = undefined;
+    let patternMatch = undefined;
+    let extensionMatch = undefined;
+    // We want to prioritize associations based on the order they are registered so that the last registered
+    // association wins over all other. This is for https://github.com/microsoft/vscode/issues/20074
+    for (let i = associations.length - 1; i >= 0; i--) {
+        const association = associations[i];
+        // First exact name match
+        if (filename === association.filenameLowercase) {
+            filenameMatch = association;
+            break; // take it!
+        }
+        // Longest pattern match
+        if (association.filepattern) {
+            if (!patternMatch || association.filepattern.length > patternMatch.filepattern.length) {
+                const target = association.filepatternOnPath ? path : filename; // match on full path if pattern contains path separator
+                if (association.filepatternLowercase?.(target)) {
+                    patternMatch = association;
+                }
+            }
+        }
+        // Longest extension match
+        if (association.extension) {
+            if (!extensionMatch || association.extension.length > extensionMatch.extension.length) {
+                if (filename.endsWith(association.extensionLowercase)) {
+                    extensionMatch = association;
+                }
+            }
+        }
+    }
+    // 1.) Exact name match has second highest priority
+    if (filenameMatch) {
+        return filenameMatch;
+    }
+    // 2.) Match on pattern
+    if (patternMatch) {
+        return patternMatch;
+    }
+    // 3.) Match on extension comes next
+    if (extensionMatch) {
+        return extensionMatch;
+    }
+    return undefined;
+}
+function getAssociationByFirstline(firstLine) {
+    if (startsWithUTF8BOM(firstLine)) {
+        firstLine = firstLine.substr(1);
+    }
+    if (firstLine.length > 0) {
+        // We want to prioritize associations based on the order they are registered so that the last registered
+        // association wins over all other. This is for https://github.com/microsoft/vscode/issues/20074
+        for (let i = registeredAssociations.length - 1; i >= 0; i--) {
+            const association = registeredAssociations[i];
+            if (!association.firstline) {
+                continue;
+            }
+            const matches = firstLine.match(association.firstline);
+            if (matches && matches.length > 0) {
+                return association;
+            }
+        }
+    }
+    return undefined;
+}

node_modules/monaco-editor/esm/vs/editor/common/services/languagesRegistry.js

@@ -0,0 +1,236 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { regExpLeadsToEndlessLoop } from '../../../base/common/strings.js';
+import { clearPlatformLanguageAssociations, getLanguageIds, registerPlatformLanguageAssociation } from './languagesAssociations.js';
+import { ModesRegistry, PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { Extensions } from '../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const NULL_LANGUAGE_ID = 'vs.editor.nullLanguage';
+export class LanguageIdCodec {
+    constructor() {
+        this._languageIdToLanguage = [];
+        this._languageToLanguageId = new Map();
+        this._register(NULL_LANGUAGE_ID, 0 /* LanguageId.Null */);
+        this._register(PLAINTEXT_LANGUAGE_ID, 1 /* LanguageId.PlainText */);
+        this._nextLanguageId = 2;
+    }
+    _register(language, languageId) {
+        this._languageIdToLanguage[languageId] = language;
+        this._languageToLanguageId.set(language, languageId);
+    }
+    register(language) {
+        if (this._languageToLanguageId.has(language)) {
+            return;
+        }
+        const languageId = this._nextLanguageId++;
+        this._register(language, languageId);
+    }
+    encodeLanguageId(languageId) {
+        return this._languageToLanguageId.get(languageId) || 0 /* LanguageId.Null */;
+    }
+    decodeLanguageId(languageId) {
+        return this._languageIdToLanguage[languageId] || NULL_LANGUAGE_ID;
+    }
+}
+export class LanguagesRegistry extends Disposable {
+    static { this.instanceCount = 0; }
+    constructor(useModesRegistry = true, warnOnOverwrite = false) {
+        super();
+        this._onDidChange = this._register(new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        LanguagesRegistry.instanceCount++;
+        this._warnOnOverwrite = warnOnOverwrite;
+        this.languageIdCodec = new LanguageIdCodec();
+        this._dynamicLanguages = [];
+        this._languages = {};
+        this._mimeTypesMap = {};
+        this._nameMap = {};
+        this._lowercaseNameMap = {};
+        if (useModesRegistry) {
+            this._initializeFromRegistry();
+            this._register(ModesRegistry.onDidChangeLanguages((m) => {
+                this._initializeFromRegistry();
+            }));
+        }
+    }
+    dispose() {
+        LanguagesRegistry.instanceCount--;
+        super.dispose();
+    }
+    _initializeFromRegistry() {
+        this._languages = {};
+        this._mimeTypesMap = {};
+        this._nameMap = {};
+        this._lowercaseNameMap = {};
+        clearPlatformLanguageAssociations();
+        const desc = [].concat(ModesRegistry.getLanguages()).concat(this._dynamicLanguages);
+        this._registerLanguages(desc);
+    }
+    _registerLanguages(desc) {
+        for (const d of desc) {
+            this._registerLanguage(d);
+        }
+        // Rebuild fast path maps
+        this._mimeTypesMap = {};
+        this._nameMap = {};
+        this._lowercaseNameMap = {};
+        Object.keys(this._languages).forEach((langId) => {
+            const language = this._languages[langId];
+            if (language.name) {
+                this._nameMap[language.name] = language.identifier;
+            }
+            language.aliases.forEach((alias) => {
+                this._lowercaseNameMap[alias.toLowerCase()] = language.identifier;
+            });
+            language.mimetypes.forEach((mimetype) => {
+                this._mimeTypesMap[mimetype] = language.identifier;
+            });
+        });
+        Registry.as(Extensions.Configuration).registerOverrideIdentifiers(this.getRegisteredLanguageIds());
+        this._onDidChange.fire();
+    }
+    _registerLanguage(lang) {
+        const langId = lang.id;
+        let resolvedLanguage;
+        if (hasOwnProperty.call(this._languages, langId)) {
+            resolvedLanguage = this._languages[langId];
+        }
+        else {
+            this.languageIdCodec.register(langId);
+            resolvedLanguage = {
+                identifier: langId,
+                name: null,
+                mimetypes: [],
+                aliases: [],
+                extensions: [],
+                filenames: [],
+                configurationFiles: [],
+                icons: []
+            };
+            this._languages[langId] = resolvedLanguage;
+        }
+        this._mergeLanguage(resolvedLanguage, lang);
+    }
+    _mergeLanguage(resolvedLanguage, lang) {
+        const langId = lang.id;
+        let primaryMime = null;
+        if (Array.isArray(lang.mimetypes) && lang.mimetypes.length > 0) {
+            resolvedLanguage.mimetypes.push(...lang.mimetypes);
+            primaryMime = lang.mimetypes[0];
+        }
+        if (!primaryMime) {
+            primaryMime = `text/x-${langId}`;
+            resolvedLanguage.mimetypes.push(primaryMime);
+        }
+        if (Array.isArray(lang.extensions)) {
+            if (lang.configuration) {
+                // insert first as this appears to be the 'primary' language definition
+                resolvedLanguage.extensions = lang.extensions.concat(resolvedLanguage.extensions);
+            }
+            else {
+                resolvedLanguage.extensions = resolvedLanguage.extensions.concat(lang.extensions);
+            }
+            for (const extension of lang.extensions) {
+                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, extension: extension }, this._warnOnOverwrite);
+            }
+        }
+        if (Array.isArray(lang.filenames)) {
+            for (const filename of lang.filenames) {
+                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, filename: filename }, this._warnOnOverwrite);
+                resolvedLanguage.filenames.push(filename);
+            }
+        }
+        if (Array.isArray(lang.filenamePatterns)) {
+            for (const filenamePattern of lang.filenamePatterns) {
+                registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, filepattern: filenamePattern }, this._warnOnOverwrite);
+            }
+        }
+        if (typeof lang.firstLine === 'string' && lang.firstLine.length > 0) {
+            let firstLineRegexStr = lang.firstLine;
+            if (firstLineRegexStr.charAt(0) !== '^') {
+                firstLineRegexStr = '^' + firstLineRegexStr;
+            }
+            try {
+                const firstLineRegex = new RegExp(firstLineRegexStr);
+                if (!regExpLeadsToEndlessLoop(firstLineRegex)) {
+                    registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, firstline: firstLineRegex }, this._warnOnOverwrite);
+                }
+            }
+            catch (err) {
+                // Most likely, the regex was bad
+                console.warn(`[${lang.id}]: Invalid regular expression \`${firstLineRegexStr}\`: `, err);
+            }
+        }
+        resolvedLanguage.aliases.push(langId);
+        let langAliases = null;
+        if (typeof lang.aliases !== 'undefined' && Array.isArray(lang.aliases)) {
+            if (lang.aliases.length === 0) {
+                // signal that this language should not get a name
+                langAliases = [null];
+            }
+            else {
+                langAliases = lang.aliases;
+            }
+        }
+        if (langAliases !== null) {
+            for (const langAlias of langAliases) {
+                if (!langAlias || langAlias.length === 0) {
+                    continue;
+                }
+                resolvedLanguage.aliases.push(langAlias);
+            }
+        }
+        const containsAliases = (langAliases !== null && langAliases.length > 0);
+        if (containsAliases && langAliases[0] === null) {
+            // signal that this language should not get a name
+        }
+        else {
+            const bestName = (containsAliases ? langAliases[0] : null) || langId;
+            if (containsAliases || !resolvedLanguage.name) {
+                resolvedLanguage.name = bestName;
+            }
+        }
+        if (lang.configuration) {
+            resolvedLanguage.configurationFiles.push(lang.configuration);
+        }
+        if (lang.icon) {
+            resolvedLanguage.icons.push(lang.icon);
+        }
+    }
+    isRegisteredLanguageId(languageId) {
+        if (!languageId) {
+            return false;
+        }
+        return hasOwnProperty.call(this._languages, languageId);
+    }
+    getRegisteredLanguageIds() {
+        return Object.keys(this._languages);
+    }
+    getLanguageIdByLanguageName(languageName) {
+        const languageNameLower = languageName.toLowerCase();
+        if (!hasOwnProperty.call(this._lowercaseNameMap, languageNameLower)) {
+            return null;
+        }
+        return this._lowercaseNameMap[languageNameLower];
+    }
+    getLanguageIdByMimeType(mimeType) {
+        if (!mimeType) {
+            return null;
+        }
+        if (hasOwnProperty.call(this._mimeTypesMap, mimeType)) {
+            return this._mimeTypesMap[mimeType];
+        }
+        return null;
+    }
+    guessLanguageIdByFilepathOrFirstLine(resource, firstLine) {
+        if (!resource && !firstLine) {
+            return [];
+        }
+        return getLanguageIds(resource, firstLine);
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/markerDecorations.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+export const IMarkerDecorationsService = createDecorator('markerDecorationsService');

node_modules/monaco-editor/esm/vs/editor/common/services/markerDecorationsService.js

@@ -0,0 +1,227 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { IMarkerService, MarkerSeverity } from '../../../platform/markers/common/markers.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { OverviewRulerLane } from '../model.js';
+import { themeColorFromId } from '../../../platform/theme/common/themeService.js';
+import { overviewRulerWarning, overviewRulerInfo, overviewRulerError } from '../core/editorColorRegistry.js';
+import { IModelService } from './model.js';
+import { Range } from '../core/range.js';
+import { Schemas } from '../../../base/common/network.js';
+import { Emitter } from '../../../base/common/event.js';
+import { minimapInfo, minimapWarning, minimapError } from '../../../platform/theme/common/colorRegistry.js';
+import { BidirectionalMap, ResourceMap } from '../../../base/common/map.js';
+import { diffSets } from '../../../base/common/collections.js';
+let MarkerDecorationsService = class MarkerDecorationsService extends Disposable {
+    constructor(modelService, _markerService) {
+        super();
+        this._markerService = _markerService;
+        this._onDidChangeMarker = this._register(new Emitter());
+        this._markerDecorations = new ResourceMap();
+        modelService.getModels().forEach(model => this._onModelAdded(model));
+        this._register(modelService.onModelAdded(this._onModelAdded, this));
+        this._register(modelService.onModelRemoved(this._onModelRemoved, this));
+        this._register(this._markerService.onMarkerChanged(this._handleMarkerChange, this));
+    }
+    dispose() {
+        super.dispose();
+        this._markerDecorations.forEach(value => value.dispose());
+        this._markerDecorations.clear();
+    }
+    getMarker(uri, decoration) {
+        const markerDecorations = this._markerDecorations.get(uri);
+        return markerDecorations ? (markerDecorations.getMarker(decoration) || null) : null;
+    }
+    _handleMarkerChange(changedResources) {
+        changedResources.forEach((resource) => {
+            const markerDecorations = this._markerDecorations.get(resource);
+            if (markerDecorations) {
+                this._updateDecorations(markerDecorations);
+            }
+        });
+    }
+    _onModelAdded(model) {
+        const markerDecorations = new MarkerDecorations(model);
+        this._markerDecorations.set(model.uri, markerDecorations);
+        this._updateDecorations(markerDecorations);
+    }
+    _onModelRemoved(model) {
+        const markerDecorations = this._markerDecorations.get(model.uri);
+        if (markerDecorations) {
+            markerDecorations.dispose();
+            this._markerDecorations.delete(model.uri);
+        }
+        // clean up markers for internal, transient models
+        if (model.uri.scheme === Schemas.inMemory
+            || model.uri.scheme === Schemas.internal
+            || model.uri.scheme === Schemas.vscode) {
+            this._markerService?.read({ resource: model.uri }).map(marker => marker.owner).forEach(owner => this._markerService.remove(owner, [model.uri]));
+        }
+    }
+    _updateDecorations(markerDecorations) {
+        // Limit to the first 500 errors/warnings
+        const markers = this._markerService.read({ resource: markerDecorations.model.uri, take: 500 });
+        if (markerDecorations.update(markers)) {
+            this._onDidChangeMarker.fire(markerDecorations.model);
+        }
+    }
+};
+MarkerDecorationsService = __decorate([
+    __param(0, IModelService),
+    __param(1, IMarkerService)
+], MarkerDecorationsService);
+export { MarkerDecorationsService };
+class MarkerDecorations extends Disposable {
+    constructor(model) {
+        super();
+        this.model = model;
+        this._map = new BidirectionalMap();
+        this._register(toDisposable(() => {
+            this.model.deltaDecorations([...this._map.values()], []);
+            this._map.clear();
+        }));
+    }
+    update(markers) {
+        // We use the fact that marker instances are not recreated when different owners
+        // update. So we can compare references to find out what changed since the last update.
+        const { added, removed } = diffSets(new Set(this._map.keys()), new Set(markers));
+        if (added.length === 0 && removed.length === 0) {
+            return false;
+        }
+        const oldIds = removed.map(marker => this._map.get(marker));
+        const newDecorations = added.map(marker => {
+            return {
+                range: this._createDecorationRange(this.model, marker),
+                options: this._createDecorationOption(marker)
+            };
+        });
+        const ids = this.model.deltaDecorations(oldIds, newDecorations);
+        for (const removedMarker of removed) {
+            this._map.delete(removedMarker);
+        }
+        for (let index = 0; index < ids.length; index++) {
+            this._map.set(added[index], ids[index]);
+        }
+        return true;
+    }
+    getMarker(decoration) {
+        return this._map.getKey(decoration.id);
+    }
+    _createDecorationRange(model, rawMarker) {
+        let ret = Range.lift(rawMarker);
+        if (rawMarker.severity === MarkerSeverity.Hint && !this._hasMarkerTag(rawMarker, 1 /* MarkerTag.Unnecessary */) && !this._hasMarkerTag(rawMarker, 2 /* MarkerTag.Deprecated */)) {
+            // * never render hints on multiple lines
+            // * make enough space for three dots
+            ret = ret.setEndPosition(ret.startLineNumber, ret.startColumn + 2);
+        }
+        ret = model.validateRange(ret);
+        if (ret.isEmpty()) {
+            const maxColumn = model.getLineLastNonWhitespaceColumn(ret.startLineNumber) ||
+                model.getLineMaxColumn(ret.startLineNumber);
+            if (maxColumn === 1 || ret.endColumn >= maxColumn) {
+                // empty line or behind eol
+                // keep the range as is, it will be rendered 1ch wide
+                return ret;
+            }
+            const word = model.getWordAtPosition(ret.getStartPosition());
+            if (word) {
+                ret = new Range(ret.startLineNumber, word.startColumn, ret.endLineNumber, word.endColumn);
+            }
+        }
+        else if (rawMarker.endColumn === Number.MAX_VALUE && rawMarker.startColumn === 1 && ret.startLineNumber === ret.endLineNumber) {
+            const minColumn = model.getLineFirstNonWhitespaceColumn(rawMarker.startLineNumber);
+            if (minColumn < ret.endColumn) {
+                ret = new Range(ret.startLineNumber, minColumn, ret.endLineNumber, ret.endColumn);
+                rawMarker.startColumn = minColumn;
+            }
+        }
+        return ret;
+    }
+    _createDecorationOption(marker) {
+        let className;
+        let color = undefined;
+        let zIndex;
+        let inlineClassName = undefined;
+        let minimap;
+        switch (marker.severity) {
+            case MarkerSeverity.Hint:
+                if (this._hasMarkerTag(marker, 2 /* MarkerTag.Deprecated */)) {
+                    className = undefined;
+                }
+                else if (this._hasMarkerTag(marker, 1 /* MarkerTag.Unnecessary */)) {
+                    className = "squiggly-unnecessary" /* ClassName.EditorUnnecessaryDecoration */;
+                }
+                else {
+                    className = "squiggly-hint" /* ClassName.EditorHintDecoration */;
+                }
+                zIndex = 0;
+                break;
+            case MarkerSeverity.Info:
+                className = "squiggly-info" /* ClassName.EditorInfoDecoration */;
+                color = themeColorFromId(overviewRulerInfo);
+                zIndex = 10;
+                minimap = {
+                    color: themeColorFromId(minimapInfo),
+                    position: 1 /* MinimapPosition.Inline */
+                };
+                break;
+            case MarkerSeverity.Warning:
+                className = "squiggly-warning" /* ClassName.EditorWarningDecoration */;
+                color = themeColorFromId(overviewRulerWarning);
+                zIndex = 20;
+                minimap = {
+                    color: themeColorFromId(minimapWarning),
+                    position: 1 /* MinimapPosition.Inline */
+                };
+                break;
+            case MarkerSeverity.Error:
+            default:
+                className = "squiggly-error" /* ClassName.EditorErrorDecoration */;
+                color = themeColorFromId(overviewRulerError);
+                zIndex = 30;
+                minimap = {
+                    color: themeColorFromId(minimapError),
+                    position: 1 /* MinimapPosition.Inline */
+                };
+                break;
+        }
+        if (marker.tags) {
+            if (marker.tags.indexOf(1 /* MarkerTag.Unnecessary */) !== -1) {
+                inlineClassName = "squiggly-inline-unnecessary" /* ClassName.EditorUnnecessaryInlineDecoration */;
+            }
+            if (marker.tags.indexOf(2 /* MarkerTag.Deprecated */) !== -1) {
+                inlineClassName = "squiggly-inline-deprecated" /* ClassName.EditorDeprecatedInlineDecoration */;
+            }
+        }
+        return {
+            description: 'marker-decoration',
+            stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,
+            className,
+            showIfCollapsed: true,
+            overviewRuler: {
+                color,
+                position: OverviewRulerLane.Right
+            },
+            minimap,
+            zIndex,
+            inlineClassName,
+        };
+    }
+    _hasMarkerTag(marker, tag) {
+        if (marker.tags) {
+            return marker.tags.indexOf(tag) >= 0;
+        }
+        return false;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/model.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+export const IModelService = createDecorator('modelService');

node_modules/monaco-editor/esm/vs/editor/common/services/modelService.js

@@ -0,0 +1,418 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ModelService_1;
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import * as platform from '../../../base/common/platform.js';
+import { TextModel } from '../model/textModel.js';
+import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
+import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import { ITextResourcePropertiesService } from './textResourceConfiguration.js';
+import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
+import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.js';
+import { StringSHA1 } from '../../../base/common/hash.js';
+import { isEditStackElement } from '../model/editStack.js';
+import { Schemas } from '../../../base/common/network.js';
+import { equals } from '../../../base/common/objects.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
+function MODEL_ID(resource) {
+    return resource.toString();
+}
+class ModelData {
+    constructor(model, onWillDispose, onDidChangeLanguage) {
+        this.model = model;
+        this._modelEventListeners = new DisposableStore();
+        this.model = model;
+        this._modelEventListeners.add(model.onWillDispose(() => onWillDispose(model)));
+        this._modelEventListeners.add(model.onDidChangeLanguage((e) => onDidChangeLanguage(model, e)));
+    }
+    dispose() {
+        this._modelEventListeners.dispose();
+    }
+}
+const DEFAULT_EOL = (platform.isLinux || platform.isMacintosh) ? 1 /* DefaultEndOfLine.LF */ : 2 /* DefaultEndOfLine.CRLF */;
+class DisposedModelInfo {
+    constructor(uri, initialUndoRedoSnapshot, time, sharesUndoRedoStack, heapSize, sha1, versionId, alternativeVersionId) {
+        this.uri = uri;
+        this.initialUndoRedoSnapshot = initialUndoRedoSnapshot;
+        this.time = time;
+        this.sharesUndoRedoStack = sharesUndoRedoStack;
+        this.heapSize = heapSize;
+        this.sha1 = sha1;
+        this.versionId = versionId;
+        this.alternativeVersionId = alternativeVersionId;
+    }
+}
+let ModelService = class ModelService extends Disposable {
+    static { ModelService_1 = this; }
+    static { this.MAX_MEMORY_FOR_CLOSED_FILES_UNDO_STACK = 20 * 1024 * 1024; }
+    constructor(_configurationService, _resourcePropertiesService, _undoRedoService, _instantiationService) {
+        super();
+        this._configurationService = _configurationService;
+        this._resourcePropertiesService = _resourcePropertiesService;
+        this._undoRedoService = _undoRedoService;
+        this._instantiationService = _instantiationService;
+        this._onModelAdded = this._register(new Emitter());
+        this.onModelAdded = this._onModelAdded.event;
+        this._onModelRemoved = this._register(new Emitter());
+        this.onModelRemoved = this._onModelRemoved.event;
+        this._onModelModeChanged = this._register(new Emitter());
+        this.onModelLanguageChanged = this._onModelModeChanged.event;
+        this._modelCreationOptionsByLanguageAndResource = Object.create(null);
+        this._models = {};
+        this._disposedModels = new Map();
+        this._disposedModelsHeapSize = 0;
+        this._register(this._configurationService.onDidChangeConfiguration(e => this._updateModelOptions(e)));
+        this._updateModelOptions(undefined);
+    }
+    static _readModelOptions(config, isForSimpleWidget) {
+        let tabSize = EDITOR_MODEL_DEFAULTS.tabSize;
+        if (config.editor && typeof config.editor.tabSize !== 'undefined') {
+            const parsedTabSize = parseInt(config.editor.tabSize, 10);
+            if (!isNaN(parsedTabSize)) {
+                tabSize = parsedTabSize;
+            }
+            if (tabSize < 1) {
+                tabSize = 1;
+            }
+        }
+        let indentSize = 'tabSize';
+        if (config.editor && typeof config.editor.indentSize !== 'undefined' && config.editor.indentSize !== 'tabSize') {
+            const parsedIndentSize = parseInt(config.editor.indentSize, 10);
+            if (!isNaN(parsedIndentSize)) {
+                indentSize = Math.max(parsedIndentSize, 1);
+            }
+        }
+        let insertSpaces = EDITOR_MODEL_DEFAULTS.insertSpaces;
+        if (config.editor && typeof config.editor.insertSpaces !== 'undefined') {
+            insertSpaces = (config.editor.insertSpaces === 'false' ? false : Boolean(config.editor.insertSpaces));
+        }
+        let newDefaultEOL = DEFAULT_EOL;
+        const eol = config.eol;
+        if (eol === '\r\n') {
+            newDefaultEOL = 2 /* DefaultEndOfLine.CRLF */;
+        }
+        else if (eol === '\n') {
+            newDefaultEOL = 1 /* DefaultEndOfLine.LF */;
+        }
+        let trimAutoWhitespace = EDITOR_MODEL_DEFAULTS.trimAutoWhitespace;
+        if (config.editor && typeof config.editor.trimAutoWhitespace !== 'undefined') {
+            trimAutoWhitespace = (config.editor.trimAutoWhitespace === 'false' ? false : Boolean(config.editor.trimAutoWhitespace));
+        }
+        let detectIndentation = EDITOR_MODEL_DEFAULTS.detectIndentation;
+        if (config.editor && typeof config.editor.detectIndentation !== 'undefined') {
+            detectIndentation = (config.editor.detectIndentation === 'false' ? false : Boolean(config.editor.detectIndentation));
+        }
+        let largeFileOptimizations = EDITOR_MODEL_DEFAULTS.largeFileOptimizations;
+        if (config.editor && typeof config.editor.largeFileOptimizations !== 'undefined') {
+            largeFileOptimizations = (config.editor.largeFileOptimizations === 'false' ? false : Boolean(config.editor.largeFileOptimizations));
+        }
+        let bracketPairColorizationOptions = EDITOR_MODEL_DEFAULTS.bracketPairColorizationOptions;
+        if (config.editor?.bracketPairColorization && typeof config.editor.bracketPairColorization === 'object') {
+            bracketPairColorizationOptions = {
+                enabled: !!config.editor.bracketPairColorization.enabled,
+                independentColorPoolPerBracketType: !!config.editor.bracketPairColorization.independentColorPoolPerBracketType
+            };
+        }
+        return {
+            isForSimpleWidget: isForSimpleWidget,
+            tabSize: tabSize,
+            indentSize: indentSize,
+            insertSpaces: insertSpaces,
+            detectIndentation: detectIndentation,
+            defaultEOL: newDefaultEOL,
+            trimAutoWhitespace: trimAutoWhitespace,
+            largeFileOptimizations: largeFileOptimizations,
+            bracketPairColorizationOptions
+        };
+    }
+    _getEOL(resource, language) {
+        if (resource) {
+            return this._resourcePropertiesService.getEOL(resource, language);
+        }
+        const eol = this._configurationService.getValue('files.eol', { overrideIdentifier: language });
+        if (eol && typeof eol === 'string' && eol !== 'auto') {
+            return eol;
+        }
+        return platform.OS === 3 /* platform.OperatingSystem.Linux */ || platform.OS === 2 /* platform.OperatingSystem.Macintosh */ ? '\n' : '\r\n';
+    }
+    _shouldRestoreUndoStack() {
+        const result = this._configurationService.getValue('files.restoreUndoStack');
+        if (typeof result === 'boolean') {
+            return result;
+        }
+        return true;
+    }
+    getCreationOptions(languageIdOrSelection, resource, isForSimpleWidget) {
+        const language = (typeof languageIdOrSelection === 'string' ? languageIdOrSelection : languageIdOrSelection.languageId);
+        let creationOptions = this._modelCreationOptionsByLanguageAndResource[language + resource];
+        if (!creationOptions) {
+            const editor = this._configurationService.getValue('editor', { overrideIdentifier: language, resource });
+            const eol = this._getEOL(resource, language);
+            creationOptions = ModelService_1._readModelOptions({ editor, eol }, isForSimpleWidget);
+            this._modelCreationOptionsByLanguageAndResource[language + resource] = creationOptions;
+        }
+        return creationOptions;
+    }
+    _updateModelOptions(e) {
+        const oldOptionsByLanguageAndResource = this._modelCreationOptionsByLanguageAndResource;
+        this._modelCreationOptionsByLanguageAndResource = Object.create(null);
+        // Update options on all models
+        const keys = Object.keys(this._models);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const modelId = keys[i];
+            const modelData = this._models[modelId];
+            const language = modelData.model.getLanguageId();
+            const uri = modelData.model.uri;
+            if (e && !e.affectsConfiguration('editor', { overrideIdentifier: language, resource: uri }) && !e.affectsConfiguration('files.eol', { overrideIdentifier: language, resource: uri })) {
+                continue; // perf: skip if this model is not affected by configuration change
+            }
+            const oldOptions = oldOptionsByLanguageAndResource[language + uri];
+            const newOptions = this.getCreationOptions(language, uri, modelData.model.isForSimpleWidget);
+            ModelService_1._setModelOptionsForModel(modelData.model, newOptions, oldOptions);
+        }
+    }
+    static _setModelOptionsForModel(model, newOptions, currentOptions) {
+        if (currentOptions && currentOptions.defaultEOL !== newOptions.defaultEOL && model.getLineCount() === 1) {
+            model.setEOL(newOptions.defaultEOL === 1 /* DefaultEndOfLine.LF */ ? 0 /* EndOfLineSequence.LF */ : 1 /* EndOfLineSequence.CRLF */);
+        }
+        if (currentOptions
+            && (currentOptions.detectIndentation === newOptions.detectIndentation)
+            && (currentOptions.insertSpaces === newOptions.insertSpaces)
+            && (currentOptions.tabSize === newOptions.tabSize)
+            && (currentOptions.indentSize === newOptions.indentSize)
+            && (currentOptions.trimAutoWhitespace === newOptions.trimAutoWhitespace)
+            && equals(currentOptions.bracketPairColorizationOptions, newOptions.bracketPairColorizationOptions)) {
+            // Same indent opts, no need to touch the model
+            return;
+        }
+        if (newOptions.detectIndentation) {
+            model.detectIndentation(newOptions.insertSpaces, newOptions.tabSize);
+            model.updateOptions({
+                trimAutoWhitespace: newOptions.trimAutoWhitespace,
+                bracketColorizationOptions: newOptions.bracketPairColorizationOptions
+            });
+        }
+        else {
+            model.updateOptions({
+                insertSpaces: newOptions.insertSpaces,
+                tabSize: newOptions.tabSize,
+                indentSize: newOptions.indentSize,
+                trimAutoWhitespace: newOptions.trimAutoWhitespace,
+                bracketColorizationOptions: newOptions.bracketPairColorizationOptions
+            });
+        }
+    }
+    // --- begin IModelService
+    _insertDisposedModel(disposedModelData) {
+        this._disposedModels.set(MODEL_ID(disposedModelData.uri), disposedModelData);
+        this._disposedModelsHeapSize += disposedModelData.heapSize;
+    }
+    _removeDisposedModel(resource) {
+        const disposedModelData = this._disposedModels.get(MODEL_ID(resource));
+        if (disposedModelData) {
+            this._disposedModelsHeapSize -= disposedModelData.heapSize;
+        }
+        this._disposedModels.delete(MODEL_ID(resource));
+        return disposedModelData;
+    }
+    _ensureDisposedModelsHeapSize(maxModelsHeapSize) {
+        if (this._disposedModelsHeapSize > maxModelsHeapSize) {
+            // we must remove some old undo stack elements to free up some memory
+            const disposedModels = [];
+            this._disposedModels.forEach(entry => {
+                if (!entry.sharesUndoRedoStack) {
+                    disposedModels.push(entry);
+                }
+            });
+            disposedModels.sort((a, b) => a.time - b.time);
+            while (disposedModels.length > 0 && this._disposedModelsHeapSize > maxModelsHeapSize) {
+                const disposedModel = disposedModels.shift();
+                this._removeDisposedModel(disposedModel.uri);
+                if (disposedModel.initialUndoRedoSnapshot !== null) {
+                    this._undoRedoService.restoreSnapshot(disposedModel.initialUndoRedoSnapshot);
+                }
+            }
+        }
+    }
+    _createModelData(value, languageIdOrSelection, resource, isForSimpleWidget) {
+        // create & save the model
+        const options = this.getCreationOptions(languageIdOrSelection, resource, isForSimpleWidget);
+        const model = this._instantiationService.createInstance(TextModel, value, languageIdOrSelection, options, resource);
+        if (resource && this._disposedModels.has(MODEL_ID(resource))) {
+            const disposedModelData = this._removeDisposedModel(resource);
+            const elements = this._undoRedoService.getElements(resource);
+            const sha1Computer = this._getSHA1Computer();
+            const sha1IsEqual = (sha1Computer.canComputeSHA1(model)
+                ? sha1Computer.computeSHA1(model) === disposedModelData.sha1
+                : false);
+            if (sha1IsEqual || disposedModelData.sharesUndoRedoStack) {
+                for (const element of elements.past) {
+                    if (isEditStackElement(element) && element.matchesResource(resource)) {
+                        element.setModel(model);
+                    }
+                }
+                for (const element of elements.future) {
+                    if (isEditStackElement(element) && element.matchesResource(resource)) {
+                        element.setModel(model);
+                    }
+                }
+                this._undoRedoService.setElementsValidFlag(resource, true, (element) => (isEditStackElement(element) && element.matchesResource(resource)));
+                if (sha1IsEqual) {
+                    model._overwriteVersionId(disposedModelData.versionId);
+                    model._overwriteAlternativeVersionId(disposedModelData.alternativeVersionId);
+                    model._overwriteInitialUndoRedoSnapshot(disposedModelData.initialUndoRedoSnapshot);
+                }
+            }
+            else {
+                if (disposedModelData.initialUndoRedoSnapshot !== null) {
+                    this._undoRedoService.restoreSnapshot(disposedModelData.initialUndoRedoSnapshot);
+                }
+            }
+        }
+        const modelId = MODEL_ID(model.uri);
+        if (this._models[modelId]) {
+            // There already exists a model with this id => this is a programmer error
+            throw new Error('ModelService: Cannot add model because it already exists!');
+        }
+        const modelData = new ModelData(model, (model) => this._onWillDispose(model), (model, e) => this._onDidChangeLanguage(model, e));
+        this._models[modelId] = modelData;
+        return modelData;
+    }
+    createModel(value, languageSelection, resource, isForSimpleWidget = false) {
+        let modelData;
+        if (languageSelection) {
+            modelData = this._createModelData(value, languageSelection, resource, isForSimpleWidget);
+        }
+        else {
+            modelData = this._createModelData(value, PLAINTEXT_LANGUAGE_ID, resource, isForSimpleWidget);
+        }
+        this._onModelAdded.fire(modelData.model);
+        return modelData.model;
+    }
+    getModels() {
+        const ret = [];
+        const keys = Object.keys(this._models);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const modelId = keys[i];
+            ret.push(this._models[modelId].model);
+        }
+        return ret;
+    }
+    getModel(resource) {
+        const modelId = MODEL_ID(resource);
+        const modelData = this._models[modelId];
+        if (!modelData) {
+            return null;
+        }
+        return modelData.model;
+    }
+    // --- end IModelService
+    _schemaShouldMaintainUndoRedoElements(resource) {
+        return (resource.scheme === Schemas.file
+            || resource.scheme === Schemas.vscodeRemote
+            || resource.scheme === Schemas.vscodeUserData
+            || resource.scheme === Schemas.vscodeNotebookCell
+            || resource.scheme === 'fake-fs' // for tests
+        );
+    }
+    _onWillDispose(model) {
+        const modelId = MODEL_ID(model.uri);
+        const modelData = this._models[modelId];
+        const sharesUndoRedoStack = (this._undoRedoService.getUriComparisonKey(model.uri) !== model.uri.toString());
+        let maintainUndoRedoStack = false;
+        let heapSize = 0;
+        if (sharesUndoRedoStack || (this._shouldRestoreUndoStack() && this._schemaShouldMaintainUndoRedoElements(model.uri))) {
+            const elements = this._undoRedoService.getElements(model.uri);
+            if (elements.past.length > 0 || elements.future.length > 0) {
+                for (const element of elements.past) {
+                    if (isEditStackElement(element) && element.matchesResource(model.uri)) {
+                        maintainUndoRedoStack = true;
+                        heapSize += element.heapSize(model.uri);
+                        element.setModel(model.uri); // remove reference from text buffer instance
+                    }
+                }
+                for (const element of elements.future) {
+                    if (isEditStackElement(element) && element.matchesResource(model.uri)) {
+                        maintainUndoRedoStack = true;
+                        heapSize += element.heapSize(model.uri);
+                        element.setModel(model.uri); // remove reference from text buffer instance
+                    }
+                }
+            }
+        }
+        const maxMemory = ModelService_1.MAX_MEMORY_FOR_CLOSED_FILES_UNDO_STACK;
+        const sha1Computer = this._getSHA1Computer();
+        if (!maintainUndoRedoStack) {
+            if (!sharesUndoRedoStack) {
+                const initialUndoRedoSnapshot = modelData.model.getInitialUndoRedoSnapshot();
+                if (initialUndoRedoSnapshot !== null) {
+                    this._undoRedoService.restoreSnapshot(initialUndoRedoSnapshot);
+                }
+            }
+        }
+        else if (!sharesUndoRedoStack && (heapSize > maxMemory || !sha1Computer.canComputeSHA1(model))) {
+            // the undo stack for this file would never fit in the configured memory or the file is very large, so don't bother with it.
+            const initialUndoRedoSnapshot = modelData.model.getInitialUndoRedoSnapshot();
+            if (initialUndoRedoSnapshot !== null) {
+                this._undoRedoService.restoreSnapshot(initialUndoRedoSnapshot);
+            }
+        }
+        else {
+            this._ensureDisposedModelsHeapSize(maxMemory - heapSize);
+            // We only invalidate the elements, but they remain in the undo-redo service.
+            this._undoRedoService.setElementsValidFlag(model.uri, false, (element) => (isEditStackElement(element) && element.matchesResource(model.uri)));
+            this._insertDisposedModel(new DisposedModelInfo(model.uri, modelData.model.getInitialUndoRedoSnapshot(), Date.now(), sharesUndoRedoStack, heapSize, sha1Computer.computeSHA1(model), model.getVersionId(), model.getAlternativeVersionId()));
+        }
+        delete this._models[modelId];
+        modelData.dispose();
+        // clean up cache
+        delete this._modelCreationOptionsByLanguageAndResource[model.getLanguageId() + model.uri];
+        this._onModelRemoved.fire(model);
+    }
+    _onDidChangeLanguage(model, e) {
+        const oldLanguageId = e.oldLanguage;
+        const newLanguageId = model.getLanguageId();
+        const oldOptions = this.getCreationOptions(oldLanguageId, model.uri, model.isForSimpleWidget);
+        const newOptions = this.getCreationOptions(newLanguageId, model.uri, model.isForSimpleWidget);
+        ModelService_1._setModelOptionsForModel(model, newOptions, oldOptions);
+        this._onModelModeChanged.fire({ model, oldLanguageId: oldLanguageId });
+    }
+    _getSHA1Computer() {
+        return new DefaultModelSHA1Computer();
+    }
+};
+ModelService = ModelService_1 = __decorate([
+    __param(0, IConfigurationService),
+    __param(1, ITextResourcePropertiesService),
+    __param(2, IUndoRedoService),
+    __param(3, IInstantiationService)
+], ModelService);
+export { ModelService };
+export class DefaultModelSHA1Computer {
+    static { this.MAX_MODEL_SIZE = 10 * 1024 * 1024; } // takes 200ms to compute a sha1 on a 10MB model on a new machine
+    canComputeSHA1(model) {
+        return (model.getValueLength() <= DefaultModelSHA1Computer.MAX_MODEL_SIZE);
+    }
+    computeSHA1(model) {
+        // compute the sha1
+        const shaComputer = new StringSHA1();
+        const snapshot = model.createSnapshot();
+        let text;
+        while ((text = snapshot.read())) {
+            shaComputer.update(text);
+        }
+        return shaComputer.digest();
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/resolverService.js

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

node_modules/monaco-editor/esm/vs/editor/common/services/semanticTokensDto.js

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { VSBuffer } from '../../../base/common/buffer.js';
+import * as platform from '../../../base/common/platform.js';
+function reverseEndianness(arr) {
+    for (let i = 0, len = arr.length; i < len; i += 4) {
+        // flip bytes 0<->3 and 1<->2
+        const b0 = arr[i + 0];
+        const b1 = arr[i + 1];
+        const b2 = arr[i + 2];
+        const b3 = arr[i + 3];
+        arr[i + 0] = b3;
+        arr[i + 1] = b2;
+        arr[i + 2] = b1;
+        arr[i + 3] = b0;
+    }
+}
+function toLittleEndianBuffer(arr) {
+    const uint8Arr = new Uint8Array(arr.buffer, arr.byteOffset, arr.length * 4);
+    if (!platform.isLittleEndian()) {
+        // the byte order must be changed
+        reverseEndianness(uint8Arr);
+    }
+    return VSBuffer.wrap(uint8Arr);
+}
+export function encodeSemanticTokensDto(semanticTokens) {
+    const dest = new Uint32Array(encodeSemanticTokensDtoSize(semanticTokens));
+    let offset = 0;
+    dest[offset++] = semanticTokens.id;
+    if (semanticTokens.type === 'full') {
+        dest[offset++] = 1 /* EncodedSemanticTokensType.Full */;
+        dest[offset++] = semanticTokens.data.length;
+        dest.set(semanticTokens.data, offset);
+        offset += semanticTokens.data.length;
+    }
+    else {
+        dest[offset++] = 2 /* EncodedSemanticTokensType.Delta */;
+        dest[offset++] = semanticTokens.deltas.length;
+        for (const delta of semanticTokens.deltas) {
+            dest[offset++] = delta.start;
+            dest[offset++] = delta.deleteCount;
+            if (delta.data) {
+                dest[offset++] = delta.data.length;
+                dest.set(delta.data, offset);
+                offset += delta.data.length;
+            }
+            else {
+                dest[offset++] = 0;
+            }
+        }
+    }
+    return toLittleEndianBuffer(dest);
+}
+function encodeSemanticTokensDtoSize(semanticTokens) {
+    let result = 0;
+    result += (+1 // id
+        + 1 // type
+    );
+    if (semanticTokens.type === 'full') {
+        result += (+1 // data length
+            + semanticTokens.data.length);
+    }
+    else {
+        result += (+1 // delta count
+        );
+        result += (+1 // start
+            + 1 // deleteCount
+            + 1 // data length
+        ) * semanticTokens.deltas.length;
+        for (const delta of semanticTokens.deltas) {
+            if (delta.data) {
+                result += delta.data.length;
+            }
+        }
+    }
+    return result;
+}

node_modules/monaco-editor/esm/vs/editor/common/services/semanticTokensProviderStyling.js

@@ -0,0 +1,276 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { TokenMetadata } from '../encodedTokenAttributes.js';
+import { IThemeService } from '../../../platform/theme/common/themeService.js';
+import { ILogService, LogLevel } from '../../../platform/log/common/log.js';
+import { SparseMultilineTokens } from '../tokens/sparseMultilineTokens.js';
+import { ILanguageService } from '../languages/language.js';
+const ENABLE_TRACE = false;
+let SemanticTokensProviderStyling = class SemanticTokensProviderStyling {
+    constructor(_legend, _themeService, _languageService, _logService) {
+        this._legend = _legend;
+        this._themeService = _themeService;
+        this._languageService = _languageService;
+        this._logService = _logService;
+        this._hasWarnedOverlappingTokens = false;
+        this._hasWarnedInvalidLengthTokens = false;
+        this._hasWarnedInvalidEditStart = false;
+        this._hashTable = new HashTable();
+    }
+    getMetadata(tokenTypeIndex, tokenModifierSet, languageId) {
+        const encodedLanguageId = this._languageService.languageIdCodec.encodeLanguageId(languageId);
+        const entry = this._hashTable.get(tokenTypeIndex, tokenModifierSet, encodedLanguageId);
+        let metadata;
+        if (entry) {
+            metadata = entry.metadata;
+            if (ENABLE_TRACE && this._logService.getLevel() === LogLevel.Trace) {
+                this._logService.trace(`SemanticTokensProviderStyling [CACHED] ${tokenTypeIndex} / ${tokenModifierSet}: foreground ${TokenMetadata.getForeground(metadata)}, fontStyle ${TokenMetadata.getFontStyle(metadata).toString(2)}`);
+            }
+        }
+        else {
+            let tokenType = this._legend.tokenTypes[tokenTypeIndex];
+            const tokenModifiers = [];
+            if (tokenType) {
+                let modifierSet = tokenModifierSet;
+                for (let modifierIndex = 0; modifierSet > 0 && modifierIndex < this._legend.tokenModifiers.length; modifierIndex++) {
+                    if (modifierSet & 1) {
+                        tokenModifiers.push(this._legend.tokenModifiers[modifierIndex]);
+                    }
+                    modifierSet = modifierSet >> 1;
+                }
+                if (ENABLE_TRACE && modifierSet > 0 && this._logService.getLevel() === LogLevel.Trace) {
+                    this._logService.trace(`SemanticTokensProviderStyling: unknown token modifier index: ${tokenModifierSet.toString(2)} for legend: ${JSON.stringify(this._legend.tokenModifiers)}`);
+                    tokenModifiers.push('not-in-legend');
+                }
+                const tokenStyle = this._themeService.getColorTheme().getTokenStyleMetadata(tokenType, tokenModifiers, languageId);
+                if (typeof tokenStyle === 'undefined') {
+                    metadata = 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */;
+                }
+                else {
+                    metadata = 0;
+                    if (typeof tokenStyle.italic !== 'undefined') {
+                        const italicBit = (tokenStyle.italic ? 1 /* FontStyle.Italic */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= italicBit | 1 /* MetadataConsts.SEMANTIC_USE_ITALIC */;
+                    }
+                    if (typeof tokenStyle.bold !== 'undefined') {
+                        const boldBit = (tokenStyle.bold ? 2 /* FontStyle.Bold */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= boldBit | 2 /* MetadataConsts.SEMANTIC_USE_BOLD */;
+                    }
+                    if (typeof tokenStyle.underline !== 'undefined') {
+                        const underlineBit = (tokenStyle.underline ? 4 /* FontStyle.Underline */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= underlineBit | 4 /* MetadataConsts.SEMANTIC_USE_UNDERLINE */;
+                    }
+                    if (typeof tokenStyle.strikethrough !== 'undefined') {
+                        const strikethroughBit = (tokenStyle.strikethrough ? 8 /* FontStyle.Strikethrough */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= strikethroughBit | 8 /* MetadataConsts.SEMANTIC_USE_STRIKETHROUGH */;
+                    }
+                    if (tokenStyle.foreground) {
+                        const foregroundBits = (tokenStyle.foreground) << 15 /* MetadataConsts.FOREGROUND_OFFSET */;
+                        metadata |= foregroundBits | 16 /* MetadataConsts.SEMANTIC_USE_FOREGROUND */;
+                    }
+                    if (metadata === 0) {
+                        // Nothing!
+                        metadata = 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */;
+                    }
+                }
+            }
+            else {
+                if (ENABLE_TRACE && this._logService.getLevel() === LogLevel.Trace) {
+                    this._logService.trace(`SemanticTokensProviderStyling: unknown token type index: ${tokenTypeIndex} for legend: ${JSON.stringify(this._legend.tokenTypes)}`);
+                }
+                metadata = 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */;
+                tokenType = 'not-in-legend';
+            }
+            this._hashTable.add(tokenTypeIndex, tokenModifierSet, encodedLanguageId, metadata);
+            if (ENABLE_TRACE && this._logService.getLevel() === LogLevel.Trace) {
+                this._logService.trace(`SemanticTokensProviderStyling ${tokenTypeIndex} (${tokenType}) / ${tokenModifierSet} (${tokenModifiers.join(' ')}): foreground ${TokenMetadata.getForeground(metadata)}, fontStyle ${TokenMetadata.getFontStyle(metadata).toString(2)}`);
+            }
+        }
+        return metadata;
+    }
+    warnOverlappingSemanticTokens(lineNumber, startColumn) {
+        if (!this._hasWarnedOverlappingTokens) {
+            this._hasWarnedOverlappingTokens = true;
+            this._logService.warn(`Overlapping semantic tokens detected at lineNumber ${lineNumber}, column ${startColumn}`);
+        }
+    }
+    warnInvalidLengthSemanticTokens(lineNumber, startColumn) {
+        if (!this._hasWarnedInvalidLengthTokens) {
+            this._hasWarnedInvalidLengthTokens = true;
+            this._logService.warn(`Semantic token with invalid length detected at lineNumber ${lineNumber}, column ${startColumn}`);
+        }
+    }
+    warnInvalidEditStart(previousResultId, resultId, editIndex, editStart, maxExpectedStart) {
+        if (!this._hasWarnedInvalidEditStart) {
+            this._hasWarnedInvalidEditStart = true;
+            this._logService.warn(`Invalid semantic tokens edit detected (previousResultId: ${previousResultId}, resultId: ${resultId}) at edit #${editIndex}: The provided start offset ${editStart} is outside the previous data (length ${maxExpectedStart}).`);
+        }
+    }
+};
+SemanticTokensProviderStyling = __decorate([
+    __param(1, IThemeService),
+    __param(2, ILanguageService),
+    __param(3, ILogService)
+], SemanticTokensProviderStyling);
+export { SemanticTokensProviderStyling };
+export function toMultilineTokens2(tokens, styling, languageId) {
+    const srcData = tokens.data;
+    const tokenCount = (tokens.data.length / 5) | 0;
+    const tokensPerArea = Math.max(Math.ceil(tokenCount / 1024 /* SemanticColoringConstants.DesiredMaxAreas */), 400 /* SemanticColoringConstants.DesiredTokensPerArea */);
+    const result = [];
+    let tokenIndex = 0;
+    let lastLineNumber = 1;
+    let lastStartCharacter = 0;
+    while (tokenIndex < tokenCount) {
+        const tokenStartIndex = tokenIndex;
+        let tokenEndIndex = Math.min(tokenStartIndex + tokensPerArea, tokenCount);
+        // Keep tokens on the same line in the same area...
+        if (tokenEndIndex < tokenCount) {
+            let smallTokenEndIndex = tokenEndIndex;
+            while (smallTokenEndIndex - 1 > tokenStartIndex && srcData[5 * smallTokenEndIndex] === 0) {
+                smallTokenEndIndex--;
+            }
+            if (smallTokenEndIndex - 1 === tokenStartIndex) {
+                // there are so many tokens on this line that our area would be empty, we must now go right
+                let bigTokenEndIndex = tokenEndIndex;
+                while (bigTokenEndIndex + 1 < tokenCount && srcData[5 * bigTokenEndIndex] === 0) {
+                    bigTokenEndIndex++;
+                }
+                tokenEndIndex = bigTokenEndIndex;
+            }
+            else {
+                tokenEndIndex = smallTokenEndIndex;
+            }
+        }
+        let destData = new Uint32Array((tokenEndIndex - tokenStartIndex) * 4);
+        let destOffset = 0;
+        let areaLine = 0;
+        let prevLineNumber = 0;
+        let prevEndCharacter = 0;
+        while (tokenIndex < tokenEndIndex) {
+            const srcOffset = 5 * tokenIndex;
+            const deltaLine = srcData[srcOffset];
+            const deltaCharacter = srcData[srcOffset + 1];
+            // Casting both `lineNumber`, `startCharacter` and `endCharacter` here to uint32 using `|0`
+            // to validate below with the actual values that will be inserted in the Uint32Array result
+            const lineNumber = (lastLineNumber + deltaLine) | 0;
+            const startCharacter = (deltaLine === 0 ? (lastStartCharacter + deltaCharacter) | 0 : deltaCharacter);
+            const length = srcData[srcOffset + 2];
+            const endCharacter = (startCharacter + length) | 0;
+            const tokenTypeIndex = srcData[srcOffset + 3];
+            const tokenModifierSet = srcData[srcOffset + 4];
+            if (endCharacter <= startCharacter) {
+                // this token is invalid (most likely a negative length casted to uint32)
+                styling.warnInvalidLengthSemanticTokens(lineNumber, startCharacter + 1);
+            }
+            else if (prevLineNumber === lineNumber && prevEndCharacter > startCharacter) {
+                // this token overlaps with the previous token
+                styling.warnOverlappingSemanticTokens(lineNumber, startCharacter + 1);
+            }
+            else {
+                const metadata = styling.getMetadata(tokenTypeIndex, tokenModifierSet, languageId);
+                if (metadata !== 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */) {
+                    if (areaLine === 0) {
+                        areaLine = lineNumber;
+                    }
+                    destData[destOffset] = lineNumber - areaLine;
+                    destData[destOffset + 1] = startCharacter;
+                    destData[destOffset + 2] = endCharacter;
+                    destData[destOffset + 3] = metadata;
+                    destOffset += 4;
+                    prevLineNumber = lineNumber;
+                    prevEndCharacter = endCharacter;
+                }
+            }
+            lastLineNumber = lineNumber;
+            lastStartCharacter = startCharacter;
+            tokenIndex++;
+        }
+        if (destOffset !== destData.length) {
+            destData = destData.subarray(0, destOffset);
+        }
+        const tokens = SparseMultilineTokens.create(areaLine, destData);
+        result.push(tokens);
+    }
+    return result;
+}
+class HashTableEntry {
+    constructor(tokenTypeIndex, tokenModifierSet, languageId, metadata) {
+        this.tokenTypeIndex = tokenTypeIndex;
+        this.tokenModifierSet = tokenModifierSet;
+        this.languageId = languageId;
+        this.metadata = metadata;
+        this.next = null;
+    }
+}
+class HashTable {
+    static { this._SIZES = [3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143]; }
+    constructor() {
+        this._elementsCount = 0;
+        this._currentLengthIndex = 0;
+        this._currentLength = HashTable._SIZES[this._currentLengthIndex];
+        this._growCount = Math.round(this._currentLengthIndex + 1 < HashTable._SIZES.length ? 2 / 3 * this._currentLength : 0);
+        this._elements = [];
+        HashTable._nullOutEntries(this._elements, this._currentLength);
+    }
+    static _nullOutEntries(entries, length) {
+        for (let i = 0; i < length; i++) {
+            entries[i] = null;
+        }
+    }
+    _hash2(n1, n2) {
+        return (((n1 << 5) - n1) + n2) | 0; // n1 * 31 + n2, keep as int32
+    }
+    _hashFunc(tokenTypeIndex, tokenModifierSet, languageId) {
+        return this._hash2(this._hash2(tokenTypeIndex, tokenModifierSet), languageId) % this._currentLength;
+    }
+    get(tokenTypeIndex, tokenModifierSet, languageId) {
+        const hash = this._hashFunc(tokenTypeIndex, tokenModifierSet, languageId);
+        let p = this._elements[hash];
+        while (p) {
+            if (p.tokenTypeIndex === tokenTypeIndex && p.tokenModifierSet === tokenModifierSet && p.languageId === languageId) {
+                return p;
+            }
+            p = p.next;
+        }
+        return null;
+    }
+    add(tokenTypeIndex, tokenModifierSet, languageId, metadata) {
+        this._elementsCount++;
+        if (this._growCount !== 0 && this._elementsCount >= this._growCount) {
+            // expand!
+            const oldElements = this._elements;
+            this._currentLengthIndex++;
+            this._currentLength = HashTable._SIZES[this._currentLengthIndex];
+            this._growCount = Math.round(this._currentLengthIndex + 1 < HashTable._SIZES.length ? 2 / 3 * this._currentLength : 0);
+            this._elements = [];
+            HashTable._nullOutEntries(this._elements, this._currentLength);
+            for (const first of oldElements) {
+                let p = first;
+                while (p) {
+                    const oldNext = p.next;
+                    p.next = null;
+                    this._add(p);
+                    p = oldNext;
+                }
+            }
+        }
+        this._add(new HashTableEntry(tokenTypeIndex, tokenModifierSet, languageId, metadata));
+    }
+    _add(element) {
+        const hash = this._hashFunc(element.tokenTypeIndex, element.tokenModifierSet, element.languageId);
+        element.next = this._elements[hash];
+        this._elements[hash] = element;
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/semanticTokensStyling.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+export const ISemanticTokensStylingService = createDecorator('semanticTokensStylingService');

node_modules/monaco-editor/esm/vs/editor/common/services/semanticTokensStylingService.js

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { ILanguageService } from '../languages/language.js';
+import { IThemeService } from '../../../platform/theme/common/themeService.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { SemanticTokensProviderStyling } from './semanticTokensProviderStyling.js';
+import { ISemanticTokensStylingService } from './semanticTokensStyling.js';
+import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+let SemanticTokensStylingService = class SemanticTokensStylingService extends Disposable {
+    constructor(_themeService, _logService, _languageService) {
+        super();
+        this._themeService = _themeService;
+        this._logService = _logService;
+        this._languageService = _languageService;
+        this._caches = new WeakMap();
+        this._register(this._themeService.onDidColorThemeChange(() => {
+            this._caches = new WeakMap();
+        }));
+    }
+    getStyling(provider) {
+        if (!this._caches.has(provider)) {
+            this._caches.set(provider, new SemanticTokensProviderStyling(provider.getLegend(), this._themeService, this._languageService, this._logService));
+        }
+        return this._caches.get(provider);
+    }
+};
+SemanticTokensStylingService = __decorate([
+    __param(0, IThemeService),
+    __param(1, ILogService),
+    __param(2, ILanguageService)
+], SemanticTokensStylingService);
+export { SemanticTokensStylingService };
+registerSingleton(ISemanticTokensStylingService, SemanticTokensStylingService, 1 /* InstantiationType.Delayed */);

node_modules/monaco-editor/esm/vs/editor/common/services/textModelSync/textModelSync.impl.js

@@ -0,0 +1,304 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { IntervalTimer } from '../../../../base/common/async.js';
+import { Disposable, DisposableStore, dispose, toDisposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Position } from '../../core/position.js';
+import { Range } from '../../core/range.js';
+import { ensureValidWordDefinition, getWordAtText } from '../../core/wordHelper.js';
+import { MirrorTextModel as BaseMirrorModel } from '../../model/mirrorTextModel.js';
+/**
+ * Stop syncing a model to the worker if it was not needed for 1 min.
+ */
+export const STOP_SYNC_MODEL_DELTA_TIME_MS = 60 * 1000;
+export class WorkerTextModelSyncClient extends Disposable {
+    constructor(proxy, modelService, keepIdleModels = false) {
+        super();
+        this._syncedModels = Object.create(null);
+        this._syncedModelsLastUsedTime = Object.create(null);
+        this._proxy = proxy;
+        this._modelService = modelService;
+        if (!keepIdleModels) {
+            const timer = new IntervalTimer();
+            timer.cancelAndSet(() => this._checkStopModelSync(), Math.round(STOP_SYNC_MODEL_DELTA_TIME_MS / 2));
+            this._register(timer);
+        }
+    }
+    dispose() {
+        for (const modelUrl in this._syncedModels) {
+            dispose(this._syncedModels[modelUrl]);
+        }
+        this._syncedModels = Object.create(null);
+        this._syncedModelsLastUsedTime = Object.create(null);
+        super.dispose();
+    }
+    ensureSyncedResources(resources, forceLargeModels = false) {
+        for (const resource of resources) {
+            const resourceStr = resource.toString();
+            if (!this._syncedModels[resourceStr]) {
+                this._beginModelSync(resource, forceLargeModels);
+            }
+            if (this._syncedModels[resourceStr]) {
+                this._syncedModelsLastUsedTime[resourceStr] = (new Date()).getTime();
+            }
+        }
+    }
+    _checkStopModelSync() {
+        const currentTime = (new Date()).getTime();
+        const toRemove = [];
+        for (const modelUrl in this._syncedModelsLastUsedTime) {
+            const elapsedTime = currentTime - this._syncedModelsLastUsedTime[modelUrl];
+            if (elapsedTime > STOP_SYNC_MODEL_DELTA_TIME_MS) {
+                toRemove.push(modelUrl);
+            }
+        }
+        for (const e of toRemove) {
+            this._stopModelSync(e);
+        }
+    }
+    _beginModelSync(resource, forceLargeModels) {
+        const model = this._modelService.getModel(resource);
+        if (!model) {
+            return;
+        }
+        if (!forceLargeModels && model.isTooLargeForSyncing()) {
+            return;
+        }
+        const modelUrl = resource.toString();
+        this._proxy.$acceptNewModel({
+            url: model.uri.toString(),
+            lines: model.getLinesContent(),
+            EOL: model.getEOL(),
+            versionId: model.getVersionId()
+        });
+        const toDispose = new DisposableStore();
+        toDispose.add(model.onDidChangeContent((e) => {
+            this._proxy.$acceptModelChanged(modelUrl.toString(), e);
+        }));
+        toDispose.add(model.onWillDispose(() => {
+            this._stopModelSync(modelUrl);
+        }));
+        toDispose.add(toDisposable(() => {
+            this._proxy.$acceptRemovedModel(modelUrl);
+        }));
+        this._syncedModels[modelUrl] = toDispose;
+    }
+    _stopModelSync(modelUrl) {
+        const toDispose = this._syncedModels[modelUrl];
+        delete this._syncedModels[modelUrl];
+        delete this._syncedModelsLastUsedTime[modelUrl];
+        dispose(toDispose);
+    }
+}
+export class WorkerTextModelSyncServer {
+    constructor() {
+        this._models = Object.create(null);
+    }
+    getModel(uri) {
+        return this._models[uri];
+    }
+    getModels() {
+        const all = [];
+        Object.keys(this._models).forEach((key) => all.push(this._models[key]));
+        return all;
+    }
+    $acceptNewModel(data) {
+        this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);
+    }
+    $acceptModelChanged(uri, e) {
+        if (!this._models[uri]) {
+            return;
+        }
+        const model = this._models[uri];
+        model.onEvents(e);
+    }
+    $acceptRemovedModel(uri) {
+        if (!this._models[uri]) {
+            return;
+        }
+        delete this._models[uri];
+    }
+}
+export class MirrorModel extends BaseMirrorModel {
+    get uri() {
+        return this._uri;
+    }
+    get eol() {
+        return this._eol;
+    }
+    getValue() {
+        return this.getText();
+    }
+    findMatches(regex) {
+        const matches = [];
+        for (let i = 0; i < this._lines.length; i++) {
+            const line = this._lines[i];
+            const offsetToAdd = this.offsetAt(new Position(i + 1, 1));
+            const iteratorOverMatches = line.matchAll(regex);
+            for (const match of iteratorOverMatches) {
+                if (match.index || match.index === 0) {
+                    match.index = match.index + offsetToAdd;
+                }
+                matches.push(match);
+            }
+        }
+        return matches;
+    }
+    getLinesContent() {
+        return this._lines.slice(0);
+    }
+    getLineCount() {
+        return this._lines.length;
+    }
+    getLineContent(lineNumber) {
+        return this._lines[lineNumber - 1];
+    }
+    getWordAtPosition(position, wordDefinition) {
+        const wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);
+        if (wordAtText) {
+            return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);
+        }
+        return null;
+    }
+    words(wordDefinition) {
+        const lines = this._lines;
+        const wordenize = this._wordenize.bind(this);
+        let lineNumber = 0;
+        let lineText = '';
+        let wordRangesIdx = 0;
+        let wordRanges = [];
+        return {
+            *[Symbol.iterator]() {
+                while (true) {
+                    if (wordRangesIdx < wordRanges.length) {
+                        const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);
+                        wordRangesIdx += 1;
+                        yield value;
+                    }
+                    else {
+                        if (lineNumber < lines.length) {
+                            lineText = lines[lineNumber];
+                            wordRanges = wordenize(lineText, wordDefinition);
+                            wordRangesIdx = 0;
+                            lineNumber += 1;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+        };
+    }
+    getLineWords(lineNumber, wordDefinition) {
+        const content = this._lines[lineNumber - 1];
+        const ranges = this._wordenize(content, wordDefinition);
+        const words = [];
+        for (const range of ranges) {
+            words.push({
+                word: content.substring(range.start, range.end),
+                startColumn: range.start + 1,
+                endColumn: range.end + 1
+            });
+        }
+        return words;
+    }
+    _wordenize(content, wordDefinition) {
+        const result = [];
+        let match;
+        wordDefinition.lastIndex = 0; // reset lastIndex just to be sure
+        while (match = wordDefinition.exec(content)) {
+            if (match[0].length === 0) {
+                // it did match the empty string
+                break;
+            }
+            result.push({ start: match.index, end: match.index + match[0].length });
+        }
+        return result;
+    }
+    getValueInRange(range) {
+        range = this._validateRange(range);
+        if (range.startLineNumber === range.endLineNumber) {
+            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);
+        }
+        const lineEnding = this._eol;
+        const startLineIndex = range.startLineNumber - 1;
+        const endLineIndex = range.endLineNumber - 1;
+        const resultLines = [];
+        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));
+        for (let i = startLineIndex + 1; i < endLineIndex; i++) {
+            resultLines.push(this._lines[i]);
+        }
+        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));
+        return resultLines.join(lineEnding);
+    }
+    offsetAt(position) {
+        position = this._validatePosition(position);
+        this._ensureLineStarts();
+        return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);
+    }
+    positionAt(offset) {
+        offset = Math.floor(offset);
+        offset = Math.max(0, offset);
+        this._ensureLineStarts();
+        const out = this._lineStarts.getIndexOf(offset);
+        const lineLength = this._lines[out.index].length;
+        // Ensure we return a valid position
+        return {
+            lineNumber: 1 + out.index,
+            column: 1 + Math.min(out.remainder, lineLength)
+        };
+    }
+    _validateRange(range) {
+        const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });
+        const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });
+        if (start.lineNumber !== range.startLineNumber
+            || start.column !== range.startColumn
+            || end.lineNumber !== range.endLineNumber
+            || end.column !== range.endColumn) {
+            return {
+                startLineNumber: start.lineNumber,
+                startColumn: start.column,
+                endLineNumber: end.lineNumber,
+                endColumn: end.column
+            };
+        }
+        return range;
+    }
+    _validatePosition(position) {
+        if (!Position.isIPosition(position)) {
+            throw new Error('bad position');
+        }
+        let { lineNumber, column } = position;
+        let hasChanged = false;
+        if (lineNumber < 1) {
+            lineNumber = 1;
+            column = 1;
+            hasChanged = true;
+        }
+        else if (lineNumber > this._lines.length) {
+            lineNumber = this._lines.length;
+            column = this._lines[lineNumber - 1].length + 1;
+            hasChanged = true;
+        }
+        else {
+            const maxCharacter = this._lines[lineNumber - 1].length + 1;
+            if (column < 1) {
+                column = 1;
+                hasChanged = true;
+            }
+            else if (column > maxCharacter) {
+                column = maxCharacter;
+                hasChanged = true;
+            }
+        }
+        if (!hasChanged) {
+            return position;
+        }
+        else {
+            return { lineNumber, column };
+        }
+    }
+}

node_modules/monaco-editor/esm/vs/editor/common/services/textModelSync/textModelSync.protocol.js

@@ -0,0 +1,5 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export {};

node_modules/monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js

@@ -0,0 +1,3 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+export const ITextResourceConfigurationService = createDecorator('textResourceConfigurationService');
+export const ITextResourcePropertiesService = createDecorator('textResourcePropertiesService');

node_modules/monaco-editor/esm/vs/editor/common/services/treeSitterParserService.js

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

node_modules/monaco-editor/esm/vs/editor/common/services/treeViewsDnd.js

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class TreeViewsDnDService {
+    constructor() {
+        this._dragOperations = new Map();
+    }
+    removeDragOperationTransfer(uuid) {
+        if ((uuid && this._dragOperations.has(uuid))) {
+            const operation = this._dragOperations.get(uuid);
+            this._dragOperations.delete(uuid);
+            return operation;
+        }
+        return undefined;
+    }
+}
+export class DraggedTreeItemsIdentifier {
+    constructor(identifier) {
+        this.identifier = identifier;
+    }
+}