@codingame/monaco-vscode-api 1.76.2 → 1.76.3-next.0

package/dist/textFileEditorModel.js

@@ -0,0 +1,2985 @@
+import { _ as __decorate, E as Emitter, a as __param, X as ETAG_DISABLED, Z as NotModifiedSinceFileOperationError, n as IFileService, l as ITextFileService, r as IPathService } from './services2.js';
+import { b$ as SaveSourceRegistry, c6 as LanguageDetectionLanguageEventSource, bP as ILanguageDetectionService, c0 as IWorkingCopyBackupService, I as IWorkingCopyService, c3 as IFilesConfigurationService, bp as IExtensionService } from './missing-services.js';
+import { Disposable, combinedDisposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { R as Range, S as Selection, P as Position, w as withUndefinedAsNull, K as listenStream, Q as newWriteableStream } from './polyfill.js';
+import { ThrottledDelayer, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
+import { C as CancellationTokenSource } from './cancellation.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { T as TaskSequentializer } from './async.js';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { EDITOR_MODEL_DEFAULTS } from 'monaco-editor/esm/vs/editor/common/core/textModelDefaults.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import { PieceTreeTextBufferBuilder } from 'monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';
+import { guessIndentation } from 'monaco-editor/esm/vs/editor/common/model/indentationGuesser.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { BracketPairsTextModelPart } from 'monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsImpl.js';
+import { GuidesTextModelPart } from 'monaco-editor/esm/vs/editor/common/model/guidesTextModelPart.js';
+import { ColorizedBracketPairsDecorationProvider } from 'monaco-editor/esm/vs/editor/common/model/bracketPairsTextModelPart/colorizedBracketPairsDecorationProvider.js';
+import { TokenizationTextModelPart } from 'monaco-editor/esm/vs/editor/common/model/tokenizationTextModelPart.js';
+import { singleLetterHash, UNUSUAL_LINE_TERMINATORS, isHighSurrogate } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { EditStack } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
+import { InternalModelContentChangeEvent, ModelRawContentChangedEvent, ModelRawFlush, ModelRawEOLChanged, LineInjectedText, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, ModelInjectedTextChangedEvent } from 'monaco-editor/esm/vs/editor/common/textModelEvents.js';
+import { illegalArgument, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { recomputeMaxEnd, IntervalNode, IntervalTree } from 'monaco-editor/esm/vs/editor/common/model/intervalTree.js';
+import { normalizeIndentation } from 'monaco-editor/esm/vs/editor/common/core/indentation.js';
+import { TextModelSearch, SearchParams } from 'monaco-editor/esm/vs/editor/common/model/textModelSearch.js';
+import { ValidAnnotatedEditOperation, isITextSnapshot, OverviewRulerLane } from 'monaco-editor/esm/vs/editor/common/model.js';
+import { countEOL } from 'monaco-editor/esm/vs/editor/common/core/eolCounter.js';
+import { pushMany, ArrayQueue } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { PieceTreeTextBuffer } from 'monaco-editor/esm/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBuffer.js';
+import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
+import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import { extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { withNullAsUndefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+const TextModelResolvedOptions = monaco.editor.TextModelResolvedOptions;
+function createTextBufferFactory(text) {
+    const builder = ( (new PieceTreeTextBufferBuilder()));
+    builder.acceptChunk(text);
+    return builder.finish();
+}
+function createTextBufferFactoryFromStream(stream) {
+    return (
+         (new Promise((resolve, reject) => {
+            const builder = ( (new PieceTreeTextBufferBuilder()));
+            let done = false;
+            listenStream(stream, {
+                onData: chunk => {
+                    builder.acceptChunk((typeof chunk === 'string') ? chunk : ( (chunk.toString())));
+                },
+                onError: error => {
+                    if (!done) {
+                        done = true;
+                        reject(error);
+                    }
+                },
+                onEnd: () => {
+                    if (!done) {
+                        done = true;
+                        resolve(builder.finish());
+                    }
+                }
+            });
+        }))
+    );
+}
+function createTextBufferFactoryFromSnapshot(snapshot) {
+    const builder = ( (new PieceTreeTextBufferBuilder()));
+    let chunk;
+    while (typeof (chunk = snapshot.read()) === 'string') {
+        builder.acceptChunk(chunk);
+    }
+    return builder.finish();
+}
+function createTextBuffer(value, defaultEOL) {
+    let factory;
+    if (typeof value === 'string') {
+        factory = createTextBufferFactory(value);
+    }
+    else if (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) {
+                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 resolveOptions(textBuffer, options) {
+        if (options.detectIndentation) {
+            const guessedIndentation = guessIndentation(textBuffer, options.tabSize, options.insertSpaces);
+            return new TextModelResolvedOptions({
+                tabSize: guessedIndentation.tabSize,
+                indentSize: 'tabSize',
+                insertSpaces: guessedIndentation.insertSpaces,
+                trimAutoWhitespace: options.trimAutoWhitespace,
+                defaultEOL: options.defaultEOL,
+                bracketPairColorizationOptions: options.bracketPairColorizationOptions,
+            });
+        }
+        return new 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, languageId, creationOptions, associatedResource = null, _undoRedoService, _languageService, _languageConfigurationService) {
+        super();
+        this._undoRedoService = _undoRedoService;
+        this._languageService = _languageService;
+        this._languageConfigurationService = _languageConfigurationService;
+        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._deltaDecorationCallCnt = 0;
+        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.resolveOptions(this._buffer, creationOptions);
+        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 = ( (new TokenizationTextModelPart(
+            this._languageService,
+            this._languageConfigurationService,
+            this,
+            this._bracketPairs,
+            languageId
+        )));
+        const bufferLineCount = this._buffer.getLineCount();
+        const bufferTextLength = this._buffer.getValueLengthInRange(( (new Range(1, 1, bufferLineCount, this._buffer.getLineLength(bufferLineCount) + 1))), 0 );
+        if (creationOptions.largeFileOptimizations) {
+            this._isTooLargeForTokenization = ((bufferTextLength > TextModel.LARGE_FILE_SIZE_THRESHOLD)
+                || (bufferLineCount > TextModel.LARGE_FILE_LINE_COUNT_THRESHOLD));
+        }
+        else {
+            this._isTooLargeForTokenization = false;
+        }
+        this._isTooLargeForSyncing = (bufferTextLength > TextModel._MODEL_SYNC_LIMIT);
+        this._versionId = 1;
+        this._alternativeVersionId = 1;
+        this._initialUndoRedoSnapshot = null;
+        this._isDisposed = false;
+        this.__isDisposing = false;
+        this._instanceId = 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();
+        }));
+    }
+    dispose() {
+        this.__isDisposing = true;
+        this._onWillDispose.fire();
+        this._tokenizationTextModelPart.dispose();
+        this._isDisposed = true;
+        super.dispose();
+        this._bufferDisposable.dispose();
+        this.__isDisposing = false;
+        const emptyDisposedTextBuffer = ( (new PieceTreeTextBuffer([], '', '\n', false, false, true, true)));
+        emptyDisposedTextBuffer.dispose();
+        this._buffer = emptyDisposedTextBuffer;
+        this._bufferDisposable = Disposable.None;
+    }
+    _hasListeners() {
+        return (this._onWillDispose.hasListeners()
+            || this._onDidChangeDecorations.hasListeners()
+            || this._tokenizationTextModelPart._hasListeners()
+            || this._onDidChangeOptions.hasListeners()
+            || this._onDidChangeAttached.hasListeners()
+            || this._onDidChangeInjectedText.hasListeners()
+            || this._eventEmitter.hasListeners());
+    }
+    _assertNotDisposed() {
+        if (this._isDisposed) {
+            throw new Error('Model is disposed!');
+        }
+    }
+    equalsTextBuffer(other) {
+        this._assertNotDisposed();
+        return this._buffer.equals(other);
+    }
+    getTextBuffer() {
+        this._assertNotDisposed();
+        return this._buffer;
+    }
+    _emitContentChangedEvent(rawChange, change) {
+        if (this.__isDisposing) {
+            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) {
+        return {
+            changes: [{
+                    range: range,
+                    rangeOffset: rangeOffset,
+                    rangeLength: rangeLength,
+                    text: text,
+                }],
+            eol: this._buffer.getEOL(),
+            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();
+        this._tokenizationTextModelPart.flush();
+        this._decorations = Object.create(null);
+        this._decorationsTree = ( (new DecorationsTrees()));
+        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));
+    }
+    setEOL(eol) {
+        this._assertNotDisposed();
+        const newEOL = (eol === 1  ? '\r\n' : '\n');
+        if (this._buffer.getEOL() === newEOL) {
+            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));
+    }
+    _onBeforeEOLChange() {
+        this._decorationsTree.ensureAllNodesHaveRanges(this);
+    }
+    _onAfterEOLChange() {
+        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;
+            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);
+        }
+    }
+    onBeforeDetached() {
+        this._attachedEditorCount--;
+        if (this._attachedEditorCount === 0) {
+            this._tokenizationTextModelPart.handleDidChangeAttached();
+            this._onDidChangeAttached.fire(undefined);
+        }
+    }
+    isAttachedToEditor() {
+        return this._attachedEditorCount > 0;
+    }
+    getAttachedEditorCount() {
+        return this._attachedEditorCount;
+    }
+    isTooLargeForSyncing() {
+        return this._isTooLargeForSyncing;
+    }
+    isTooLargeForTokenization() {
+        return this._isTooLargeForTokenization;
+    }
+    isDisposed() {
+        return this._isDisposed;
+    }
+    isDominatedByLongLines() {
+        this._assertNotDisposed();
+        if (this.isTooLargeForTokenization()) {
+            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;
+    }
+    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 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,
+        });
+    }
+    normalizeIndentation(str) {
+        this._assertNotDisposed();
+        return normalizeIndentation(str, this._options.indentSize, this._options.insertSpaces);
+    }
+    getVersionId() {
+        this._assertNotDisposed();
+        return this._versionId;
+    }
+    mightContainRTL() {
+        return this._buffer.mightContainRTL();
+    }
+    mightContainUnusualLineTerminators() {
+        return this._buffer.mightContainUnusualLineTerminators();
+    }
+    removeUnusualLineTerminators(selections = null) {
+        const matches = this.findMatches(UNUSUAL_LINE_TERMINATORS.source, false, true, false, null, false, 1073741824 );
+        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 );
+        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();
+        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 ) {
+        this._assertNotDisposed();
+        return this._buffer.getValueInRange(this.validateRange(rawRange), eol);
+    }
+    getValueLengthInRange(rawRange, eol = 0 ) {
+        this._assertNotDisposed();
+        return this._buffer.getValueLengthInRange(this.validateRange(rawRange), eol);
+    }
+    getCharacterCountInRange(rawRange, eol = 0 ) {
+        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 Error('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineContent(lineNumber);
+    }
+    getLineLength(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new Error('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineLength(lineNumber);
+    }
+    getLinesContent() {
+        this._assertNotDisposed();
+        return this._buffer.getLinesContent();
+    }
+    getEOL() {
+        this._assertNotDisposed();
+        return this._buffer.getEOL();
+    }
+    getEndOfLineSequence() {
+        this._assertNotDisposed();
+        return (this._buffer.getEOL() === '\n' ? 0  : 1) ;
+    }
+    getLineMinColumn(lineNumber) {
+        this._assertNotDisposed();
+        return 1;
+    }
+    getLineMaxColumn(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new Error('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineLength(lineNumber) + 1;
+    }
+    getLineFirstNonWhitespaceColumn(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new Error('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineFirstNonWhitespaceColumn(lineNumber);
+    }
+    getLineLastNonWhitespaceColumn(lineNumber) {
+        this._assertNotDisposed();
+        if (lineNumber < 1 || lineNumber > this.getLineCount()) {
+            throw new Error('Illegal value for lineNumber');
+        }
+        return this._buffer.getLineLastNonWhitespaceColumn(lineNumber);
+    }
+    _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 ) {
+            const charCodeBefore = this._buffer.getLineCharCode(lineNumber, column - 2);
+            if (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 ) {
+            const charCodeBefore = this._buffer.getLineCharCode(lineNumber, column - 2);
+            if (isHighSurrogate(charCodeBefore)) {
+                return (
+                     (new Position(lineNumber, column - 1))
+                );
+            }
+        }
+        return (
+             (new Position(lineNumber, column))
+        );
+    }
+    validatePosition(position) {
+        const validationType = 1 ;
+        this._assertNotDisposed();
+        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 )) {
+            return false;
+        }
+        if (!this._isValidPosition(endLineNumber, endColumn, 0 )) {
+            return false;
+        }
+        if (validationType === 1 ) {
+            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 = isHighSurrogate(charCodeBeforeStart);
+            const endInsideSurrogatePair = isHighSurrogate(charCodeBeforeEnd);
+            if (!startInsideSurrogatePair && !endInsideSurrogatePair) {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    validateRange(_range) {
+        const validationType = 1 ;
+        this._assertNotDisposed();
+        if ((_range instanceof Range) && !(_range instanceof Selection)) {
+            if (this._isValidRange(_range, validationType)) {
+                return _range;
+            }
+        }
+        const start = this._validatePosition(_range.startLineNumber, _range.startColumn, 0 );
+        const end = this._validatePosition(_range.endLineNumber, _range.endColumn, 0 );
+        const startLineNumber = start.lineNumber;
+        const startColumn = start.column;
+        const endLineNumber = end.lineNumber;
+        const endColumn = end.column;
+        {
+            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 = isHighSurrogate(charCodeBeforeStart);
+            const endInsideSurrogatePair = isHighSurrogate(charCodeBeforeEnd);
+            if (!startInsideSurrogatePair && !endInsideSurrogatePair) {
+                return (
+                     (new Range(startLineNumber, startColumn, endLineNumber, endColumn))
+                );
+            }
+            if (startLineNumber === endLineNumber && startColumn === endColumn) {
+                return (
+                     (new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn - 1))
+                );
+            }
+            if (startInsideSurrogatePair && endInsideSurrogatePair) {
+                return (
+                     (new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn + 1))
+                );
+            }
+            if (startInsideSurrogatePair) {
+                return (
+                     (new Range(startLineNumber, startColumn - 1, endLineNumber, endColumn))
+                );
+            }
+            return (
+                 (new Range(startLineNumber, startColumn, endLineNumber, endColumn + 1))
+            );
+        }
+    }
+    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) {
+            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);
+    }
+    pushStackElement() {
+        this._commandManager.pushStackElement();
+    }
+    popStackElement() {
+        this._commandManager.popStackElement();
+    }
+    pushEOL(eol) {
+        const currentEOL = ((this.getEOL() === '\n' ? 0  : 1) );
+        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 ValidAnnotatedEditOperation) {
+            return rawOperation;
+        }
+        return new 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) {
+            const incomingEdits = ( (editOperations.map((op) => {
+                return {
+                    range: this.validateRange(op.range),
+                    text: op.text
+                };
+            })));
+            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) {
+                            continue;
+                        }
+                        if (trimLineNumber === editRange.startLineNumber && editRange.startColumn === maxLineColumn
+                            && editRange.isEmpty() && editText && editText.length > 0 && editText.charAt(0) === '\n') {
+                            continue;
+                        }
+                        if (trimLineNumber === editRange.startLineNumber && editRange.startColumn === 1
+                            && editRange.isEmpty() && editText && editText.length > 0 && editText.charAt(editText.length - 1) === '\n') {
+                            continue;
+                        }
+                        allowTrimLine = false;
+                        break;
+                    }
+                    if (allowTrimLine) {
+                        const trimRange = ( (new Range(trimLineNumber, 1, trimLineNumber, maxLineColumn)));
+                        editOperations.push(new 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) {
+            for (let i = 0, len = contentChanges.length; i < len; i++) {
+                const change = contentChanges[i];
+                const [eolCount, firstLineLength, lastLineLength] = countEOL(change.text);
+                this._tokenizationTextModelPart.acceptEdit(change.range, change.text, eolCount, firstLineLength, lastLineLength);
+                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) {
+                    const spliceStartLineNumber = startLineNumber + editingLinesCnt;
+                    rawContentChanges.push(( (new ModelRawLinesDeleted(spliceStartLineNumber + 1, endLineNumber))));
+                }
+                if (editingLinesCnt < insertingLinesCnt) {
+                    const injectedTextInEditedRangeQueue = ( (new ArrayQueue(injectedTextInEditedRange)));
+                    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(),
+                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);
+    }
+    handleBeforeFireDecorationsChangedEvent(affectedInjectedTextLines) {
+        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) {
+                    return [];
+                }
+                return this._deltaDecorationsImpl(ownerId, oldDecorations, newDecorations);
+            }
+        };
+        let result = null;
+        try {
+            result = callback(changeAccessor);
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+        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) {
+            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) {
+                return null;
+            }
+            return this._deltaDecorationsImpl(0, [], [{ range: newRange, options: TRACKED_RANGE_OPTIONS[newStickiness] }])[0];
+        }
+        if (!newRange) {
+            this._decorationsTree.delete(node);
+            delete this._decorations[node.id];
+            return null;
+        }
+        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) {
+        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);
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(range, ownerId, filterOutValidation));
+        return decorations;
+    }
+    getDecorationsInRange(range, ownerId = 0, filterOutValidation = false, onlyMinimapDecorations = false) {
+        const validatedRange = this.validateRange(range);
+        const decorations = this._getDecorationsInRange(validatedRange, ownerId, filterOutValidation);
+        pushMany(decorations, this._decorationProvider.getDecorationsInRange(validatedRange, ownerId, filterOutValidation, onlyMinimapDecorations));
+        return decorations;
+    }
+    getOverviewRulerDecorations(ownerId = 0, filterOutValidation = false) {
+        return this._decorationsTree.getAll(this, ownerId, filterOutValidation, true);
+    }
+    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);
+        result = result.concat(this._decorationProvider.getAllDecorations(ownerId, filterOutValidation));
+        return result;
+    }
+    _getDecorationsInRange(filterRange, filterOwnerId, filterOutValidation) {
+        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);
+    }
+    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);
+        }
+        if (nodeWasInOverviewRuler !== nodeIsInOverviewRuler) {
+            this._decorationsTree.delete(node);
+            node.setOptions(options);
+            this._decorationsTree.insert(node);
+        }
+        else {
+            node.setOptions(options);
+        }
+    }
+    _deltaDecorationsImpl(ownerId, oldDecorationsIds, newDecorations) {
+        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) {
+                    do {
+                        node = this._decorations[oldDecorationsIds[oldDecorationIndex++]];
+                    } while (!node && oldDecorationIndex < oldDecorationsLen);
+                    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);
+                        this._onDidChangeDecorations.checkAffectedAndFire(node.options);
+                    }
+                }
+                if (newDecorationIndex < newDecorationsLen) {
+                    if (!node) {
+                        const internalDecorationId = (++this._lastDecorationId);
+                        const decorationId = `${this._instanceId};${internalDecorationId}`;
+                        node = ( (new IntervalNode(decorationId, 0, 0)));
+                        this._decorations[decorationId] = 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);
+                    }
+                    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();
+        }
+    }
+    getLanguageId() {
+        return this.tokenization.getLanguageId();
+    }
+    setMode(languageId, source) {
+        this.tokenization.setLanguageId(languageId, source);
+    }
+    getLanguageIdAtPosition(lineNumber, column) {
+        return this.tokenization.getLanguageIdAtPosition(lineNumber, column);
+    }
+    setLineTokens(lineNumber, tokens) {
+        this._tokenizationTextModelPart.setLineTokens(lineNumber, tokens);
+    }
+    getWordAtPosition(position) {
+        return this._tokenizationTextModelPart.getWordAtPosition(position);
+    }
+    getWordUntilPosition(position) {
+        return this._tokenizationTextModelPart.getWordUntilPosition(position);
+    }
+    normalizePosition(position, affinity) {
+        return position;
+    }
+    getLineIndentColumn(lineNumber) {
+        return indentOfLine(this.getLineContent(lineNumber)) + 1;
+    }
+};
+TextModel._MODEL_SYNC_LIMIT = 50 * 1024 * 1024;
+TextModel.LARGE_FILE_SIZE_THRESHOLD = 20 * 1024 * 1024;
+TextModel.LARGE_FILE_LINE_COUNT_THRESHOLD = 300 * 1000;
+TextModel.DEFAULT_CREATION_OPTIONS = {
+    isForSimpleWidget: false,
+    tabSize: EDITOR_MODEL_DEFAULTS.tabSize,
+    indentSize: EDITOR_MODEL_DEFAULTS.indentSize,
+    insertSpaces: EDITOR_MODEL_DEFAULTS.insertSpaces,
+    detectIndentation: false,
+    defaultEOL: 1 ,
+    trimAutoWhitespace: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
+    largeFileOptimizations: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
+    bracketPairColorizationOptions: EDITOR_MODEL_DEFAULTS.bracketPairColorizationOptions,
+};
+TextModel = ( (__decorate([
+    ( (__param(4, IUndoRedoService))),
+    ( (__param(5, ILanguageService))),
+    ( (__param(6, ILanguageConfigurationService)))
+], TextModel)));
+function indentOfLine(line) {
+    let indent = 0;
+    for (const c of line) {
+        if (c === ' ' || c === '\t') {
+            indent++;
+        }
+        else {
+            break;
+        }
+    }
+    return indent;
+}
+function isNodeInOverviewRuler(node) {
+    return (node.options.overviewRuler && node.options.overviewRuler.color ? true : false);
+}
+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);
+    }
+    _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) {
+        const versionId = host.getVersionId();
+        const result = this._intervalSearch(start, end, filterOwnerId, filterOutValidation, versionId);
+        return this._ensureNodesHaveRanges(host, result);
+    }
+    _intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId) {
+        const r0 = this._decorationsTree0.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId);
+        const r1 = this._decorationsTree1.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId);
+        const r2 = this._injectedTextDecorationsTree.intervalSearch(start, end, filterOwnerId, filterOutValidation, cachedVersionId);
+        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);
+        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);
+        return this._ensureNodesHaveRanges(host, result).filter((i) => i.options.showIfCollapsed || !i.range.isEmpty());
+    }
+    getAll(host, filterOwnerId, filterOutValidation, overviewRulerOnly) {
+        const versionId = host.getVersionId();
+        const result = this._search(filterOwnerId, filterOutValidation, overviewRulerOnly, versionId);
+        return this._ensureNodesHaveRanges(host, result);
+    }
+    _search(filterOwnerId, filterOutValidation, overviewRulerOnly, cachedVersionId) {
+        if (overviewRulerOnly) {
+            return this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId);
+        }
+        else {
+            const r0 = this._decorationsTree0.search(filterOwnerId, filterOutValidation, cachedVersionId);
+            const r1 = this._decorationsTree1.search(filterOwnerId, filterOutValidation, cachedVersionId);
+            const r2 = this._injectedTextDecorationsTree.search(filterOwnerId, filterOutValidation, cachedVersionId);
+            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 || '';
+    }
+}
+class ModelDecorationOverviewRulerOptions extends DecorationOptions {
+    constructor(options) {
+        super(options);
+        this._resolvedColor = null;
+        this.position = (typeof options.position === 'number' ? options.position : 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())
+        );
+    }
+}
+class ModelDecorationMinimapOptions extends DecorationOptions {
+    constructor(options) {
+        super(options);
+        this.position = options.position;
+    }
+    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);
+    }
+}
+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;
+    }
+}
+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.blockIsAfterEnd = options.blockIsAfterEnd ?? null;
+        this.stickiness = options.stickiness || 0 ;
+        this.zIndex = options.zIndex || 0;
+        this.className = options.className ? cleanClassName(options.className) : null;
+        this.hoverMessage = options.hoverMessage || null;
+        this.glyphMarginHoverMessage = options.glyphMarginHoverMessage || 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.glyphMarginClassName = options.glyphMarginClassName ? cleanClassName(options.glyphMarginClassName) : null;
+        this.linesDecorationsClassName = options.linesDecorationsClassName ? cleanClassName(options.linesDecorationsClassName) : 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' });
+const TRACKED_RANGE_OPTIONS = [
+    ModelDecorationOptions.register({ description: 'tracked-range-always-grows-when-typing-at-edges', stickiness: 0  }),
+    ModelDecorationOptions.register({ description: 'tracked-range-never-grows-when-typing-at-edges', stickiness: 1  }),
+    ModelDecorationOptions.register({ description: 'tracked-range-grows-only-when-typing-before', stickiness: 2  }),
+    ModelDecorationOptions.register({ description: 'tracked-range-grows-only-when-typing-after', stickiness: 3  }),
+];
+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;
+    }
+    hasListeners() {
+        return this._actual.hasListeners();
+    }
+    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) {
+        if (!this._affectsMinimap) {
+            this._affectsMinimap = options.minimap && options.minimap.position ? true : false;
+        }
+        if (!this._affectsOverviewRuler) {
+            this._affectsOverviewRuler = options.overviewRuler && options.overviewRuler.color ? true : false;
+        }
+        this.tryFire();
+    }
+    fire() {
+        this._affectsMinimap = true;
+        this._affectsOverviewRuler = 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
+        };
+        this._shouldFireDeferred = false;
+        this._affectsMinimap = false;
+        this._affectsOverviewRuler = false;
+        this._actual.fire(event);
+    }
+}
+class DidChangeContentEmitter extends Disposable {
+    constructor() {
+        super();
+        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;
+    }
+    hasListeners() {
+        return (this._fastEmitter.hasListeners()
+            || this._slowEmitter.hasListeners());
+    }
+    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);
+    }
+}
+class EditorModel extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onWillDispose = this._register(( (new Emitter())));
+        this.onWillDispose = this._onWillDispose.event;
+        this.disposed = false;
+        this.resolved = false;
+    }
+    async resolve() {
+        this.resolved = true;
+    }
+    isResolved() {
+        return this.resolved;
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+    dispose() {
+        this.disposed = true;
+        this._onWillDispose.fire();
+        super.dispose();
+    }
+}
+let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
+    constructor(modelService, languageService, languageDetectionService, accessibilityService, textEditorModelHandle) {
+        super();
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.languageDetectionService = languageDetectionService;
+        this.accessibilityService = accessibilityService;
+        this.textEditorModelHandle = undefined;
+        this.modelDisposeListener = this._register(( (new MutableDisposable())));
+        this.autoDetectLanguageThrottler = this._register(( (new ThrottledDelayer(BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY))));
+        this._hasLanguageSetExplicitly = false;
+        if (textEditorModelHandle) {
+            this.handleExistingModel(textEditorModelHandle);
+        }
+    }
+    handleExistingModel(textEditorModelHandle) {
+        const model = this.modelService.getModel(textEditorModelHandle);
+        if (!model) {
+            throw new Error(`Document with resource ${textEditorModelHandle.toString(true)} does not exist`);
+        }
+        this.textEditorModelHandle = textEditorModelHandle;
+        this.registerModelDisposeListener(model);
+    }
+    registerModelDisposeListener(model) {
+        this.modelDisposeListener.value = model.onWillDispose(() => {
+            this.textEditorModelHandle = undefined;
+            this.dispose();
+        });
+    }
+    get textEditorModel() {
+        return this.textEditorModelHandle ? this.modelService.getModel(this.textEditorModelHandle) : null;
+    }
+    isReadonly() {
+        return true;
+    }
+    get hasLanguageSetExplicitly() { return this._hasLanguageSetExplicitly; }
+    setLanguageId(languageId, source) {
+        this._hasLanguageSetExplicitly = true;
+        this.setLanguageIdInternal(languageId, source);
+    }
+    setLanguageIdInternal(languageId, source) {
+        if (!this.isResolved()) {
+            return;
+        }
+        if (!languageId || languageId === this.textEditorModel.getLanguageId()) {
+            return;
+        }
+        this.modelService.setMode(this.textEditorModel, this.languageService.createById(languageId), source);
+    }
+    installModelListeners(model) {
+        const disposable = this._register(model.onDidChangeLanguage((e) => {
+            if (e.source === LanguageDetectionLanguageEventSource) {
+                return;
+            }
+            this._hasLanguageSetExplicitly = true;
+            disposable.dispose();
+        }));
+    }
+    getLanguageId() {
+        return this.textEditorModel?.getLanguageId();
+    }
+    autoDetectLanguage() {
+        return this.autoDetectLanguageThrottler.trigger(() => this.doAutoDetectLanguage());
+    }
+    async doAutoDetectLanguage() {
+        if (this.hasLanguageSetExplicitly ||
+            !this.textEditorModelHandle ||
+            !this.languageDetectionService.isEnabledForLanguage(this.getLanguageId() ?? PLAINTEXT_LANGUAGE_ID)
+        ) {
+            return;
+        }
+        const lang = await this.languageDetectionService.detectLanguage(this.textEditorModelHandle);
+        if (lang && !this.isDisposed()) {
+            this.setLanguageIdInternal(lang, LanguageDetectionLanguageEventSource);
+            const languageName = this.languageService.getLanguageName(lang);
+            if (languageName) {
+                this.accessibilityService.alert(( (localize(
+                    'languageAutoDetected',
+                    "Language {0} was automatically detected and set as the language mode.",
+                    languageName
+                ))));
+            }
+        }
+    }
+    createTextEditorModel(value, resource, preferredLanguageId) {
+        const firstLineText = this.getFirstLineText(value);
+        const languageSelection = this.getOrCreateLanguage(resource, this.languageService, preferredLanguageId, firstLineText);
+        return this.doCreateTextEditorModel(value, languageSelection, resource);
+    }
+    doCreateTextEditorModel(value, languageSelection, resource) {
+        let model = resource && this.modelService.getModel(resource);
+        if (!model) {
+            model = this.modelService.createModel(value, languageSelection, resource);
+            this.createdEditorModel = true;
+            this.registerModelDisposeListener(model);
+        }
+        else {
+            this.updateTextEditorModel(value, languageSelection.languageId);
+        }
+        this.textEditorModelHandle = model.uri;
+        return model;
+    }
+    getFirstLineText(value) {
+        const textBufferFactory = value;
+        if (typeof textBufferFactory.getFirstLineText === 'function') {
+            return textBufferFactory.getFirstLineText(1000 );
+        }
+        const textSnapshot = value;
+        return textSnapshot.getLineContent(1).substr(0, 1000 );
+    }
+    getOrCreateLanguage(resource, languageService, preferredLanguage, firstLineText) {
+        if (!preferredLanguage || preferredLanguage === PLAINTEXT_LANGUAGE_ID) {
+            return languageService.createByFilepathOrFirstLine(withUndefinedAsNull(resource), firstLineText);
+        }
+        return languageService.createById(preferredLanguage);
+    }
+    updateTextEditorModel(newValue, preferredLanguageId) {
+        if (!this.isResolved()) {
+            return;
+        }
+        if (newValue) {
+            this.modelService.updateModel(this.textEditorModel, newValue);
+        }
+        if (preferredLanguageId && preferredLanguageId !== PLAINTEXT_LANGUAGE_ID && this.textEditorModel.getLanguageId() !== preferredLanguageId) {
+            this.modelService.setMode(this.textEditorModel, this.languageService.createById(preferredLanguageId));
+        }
+    }
+    createSnapshot() {
+        if (!this.textEditorModel) {
+            return null;
+        }
+        return this.textEditorModel.createSnapshot(true );
+    }
+    isResolved() {
+        return !!this.textEditorModelHandle;
+    }
+    dispose() {
+        this.modelDisposeListener.dispose();
+        if (this.textEditorModelHandle && this.createdEditorModel) {
+            this.modelService.destroyModel(this.textEditorModelHandle);
+        }
+        this.textEditorModelHandle = undefined;
+        this.createdEditorModel = false;
+        super.dispose();
+    }
+};
+BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY = 600;
+BaseTextEditorModel = ( (__decorate([
+    ( (__param(0, IModelService))),
+    ( (__param(1, ILanguageService))),
+    ( (__param(2, ILanguageDetectionService))),
+    ( (__param(3, IAccessibilityService)))
+], BaseTextEditorModel)));
+const NO_TYPE_ID = '';
+const UTF8 = 'utf8';
+const UTF8_with_bom = 'utf8bom';
+const UTF16be = 'utf16be';
+const UTF16le = 'utf16le';
+const UTF16be_BOM = [0xFE, 0xFF];
+const UTF16le_BOM = [0xFF, 0xFE];
+const UTF8_BOM = [0xEF, 0xBB, 0xBF];
+const ZERO_BYTE_DETECTION_BUFFER_MAX_LEN = 512;
+const NO_ENCODING_GUESS_MIN_BYTES = 512;
+const AUTO_ENCODING_GUESS_MIN_BYTES = 512 * 8;
+const AUTO_ENCODING_GUESS_MAX_BYTES = 512 * 128;
+class DecodeStreamError extends Error {
+    constructor(message, decodeStreamErrorKind) {
+        super(message);
+        this.decodeStreamErrorKind = decodeStreamErrorKind;
+    }
+}
+class DecoderStream {
+    static async create(encoding) {
+        let decoder = undefined;
+        if (encoding !== UTF8) {
+            const iconv = await import('./iconv.js').then(module => module.default ?? module);
+            decoder = iconv.getDecoder(toNodeEncoding(encoding));
+        }
+        else {
+            const utf8TextDecoder = ( (new TextDecoder()));
+            decoder = {
+                write(buffer) {
+                    return utf8TextDecoder.decode(buffer, {
+                        stream: true
+                    });
+                },
+                end() {
+                    return utf8TextDecoder.decode();
+                }
+            };
+        }
+        return (
+             (new DecoderStream(decoder))
+        );
+    }
+    constructor(iconvLiteDecoder) {
+        this.iconvLiteDecoder = iconvLiteDecoder;
+    }
+    write(buffer) {
+        return this.iconvLiteDecoder.write(buffer);
+    }
+    end() {
+        return this.iconvLiteDecoder.end();
+    }
+}
+function toDecodeStream(source, options) {
+    const minBytesRequiredForDetection = options.minBytesRequiredForDetection ?? options.guessEncoding ? AUTO_ENCODING_GUESS_MIN_BYTES : NO_ENCODING_GUESS_MIN_BYTES;
+    return (
+         (new Promise((resolve, reject) => {
+            const target = newWriteableStream(strings => strings.join(''));
+            const bufferedChunks = [];
+            let bytesBuffered = 0;
+            let decoder = undefined;
+            const createDecoder = async () => {
+                try {
+                    const detected = await detectEncodingFromBuffer({
+                        buffer: VSBuffer.concat(bufferedChunks),
+                        bytesRead: bytesBuffered
+                    }, options.guessEncoding);
+                    if (detected.seemsBinary && options.acceptTextOnly) {
+                        throw new DecodeStreamError('Stream is binary but only text is accepted for decoding', 1 );
+                    }
+                    detected.encoding = await options.overwriteEncoding(detected.encoding);
+                    decoder = await DecoderStream.create(detected.encoding);
+                    const decoded = decoder.write(VSBuffer.concat(bufferedChunks).buffer);
+                    target.write(decoded);
+                    bufferedChunks.length = 0;
+                    bytesBuffered = 0;
+                    resolve({
+                        stream: target,
+                        detected
+                    });
+                }
+                catch (error) {
+                    sourceListener?.dispose();
+                    target.destroy();
+                    reject(error);
+                }
+            };
+            const sourceListener = listenStream(source, {
+                onData: async (chunk) => {
+                    if (decoder) {
+                        target.write(decoder.write(chunk.buffer));
+                    }
+                    else {
+                        bufferedChunks.push(chunk);
+                        bytesBuffered += chunk.byteLength;
+                        if (bytesBuffered >= minBytesRequiredForDetection) {
+                            source.pause();
+                            await createDecoder();
+                            setTimeout(() => source.resume());
+                        }
+                    }
+                },
+                onError: error => target.error(error),
+                onEnd: async () => {
+                    if (!decoder) {
+                        await createDecoder();
+                    }
+                    target.end(decoder?.end());
+                }
+            });
+        }))
+    );
+}
+async function toEncodeReadable(readable, encoding, options) {
+    const iconv = await import('./iconv.js').then(module => module.default ?? module);
+    const encoder = iconv.getEncoder(toNodeEncoding(encoding), options);
+    let bytesWritten = false;
+    let done = false;
+    return {
+        read() {
+            if (done) {
+                return null;
+            }
+            const chunk = readable.read();
+            if (typeof chunk !== 'string') {
+                done = true;
+                if (!bytesWritten && options?.addBOM) {
+                    switch (encoding) {
+                        case UTF8:
+                        case UTF8_with_bom:
+                            return VSBuffer.wrap(Uint8Array.from(UTF8_BOM));
+                        case UTF16be:
+                            return VSBuffer.wrap(Uint8Array.from(UTF16be_BOM));
+                        case UTF16le:
+                            return VSBuffer.wrap(Uint8Array.from(UTF16le_BOM));
+                    }
+                }
+                const leftovers = encoder.end();
+                if (leftovers && leftovers.length > 0) {
+                    bytesWritten = true;
+                    return VSBuffer.wrap(leftovers);
+                }
+                return null;
+            }
+            bytesWritten = true;
+            return VSBuffer.wrap(encoder.write(chunk));
+        }
+    };
+}
+async function encodingExists(encoding) {
+    const iconv = await import('./iconv.js').then(module => module.default ?? module);
+    return iconv.encodingExists(toNodeEncoding(encoding));
+}
+function toNodeEncoding(enc) {
+    if (enc === UTF8_with_bom || enc === null) {
+        return UTF8;
+    }
+    return enc;
+}
+function detectEncodingByBOMFromBuffer(buffer, bytesRead) {
+    if (!buffer || bytesRead < UTF16be_BOM.length) {
+        return null;
+    }
+    const b0 = buffer.readUInt8(0);
+    const b1 = buffer.readUInt8(1);
+    if (b0 === UTF16be_BOM[0] && b1 === UTF16be_BOM[1]) {
+        return UTF16be;
+    }
+    if (b0 === UTF16le_BOM[0] && b1 === UTF16le_BOM[1]) {
+        return UTF16le;
+    }
+    if (bytesRead < UTF8_BOM.length) {
+        return null;
+    }
+    const b2 = buffer.readUInt8(2);
+    if (b0 === UTF8_BOM[0] && b1 === UTF8_BOM[1] && b2 === UTF8_BOM[2]) {
+        return UTF8_with_bom;
+    }
+    return null;
+}
+const IGNORE_ENCODINGS = ['ascii', 'utf-16', 'utf-32'];
+async function guessEncodingByBuffer(buffer) {
+    const jschardet = await import('./jschardet.js').then(module => module.default ?? module);
+    const limitedBuffer = buffer.slice(0, AUTO_ENCODING_GUESS_MAX_BYTES);
+    const binaryString = encodeLatin1(limitedBuffer.buffer);
+    const guessed = jschardet.detect(binaryString);
+    if (!guessed || !guessed.encoding) {
+        return null;
+    }
+    const enc = guessed.encoding.toLowerCase();
+    if (0 <= IGNORE_ENCODINGS.indexOf(enc)) {
+        return null;
+    }
+    return toIconvLiteEncoding(guessed.encoding);
+}
+const JSCHARDET_TO_ICONV_ENCODINGS = {
+    'ibm866': 'cp866',
+    'big5': 'cp950'
+};
+function toIconvLiteEncoding(encodingName) {
+    const normalizedEncodingName = encodingName.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+    const mapped = JSCHARDET_TO_ICONV_ENCODINGS[normalizedEncodingName];
+    return mapped || normalizedEncodingName;
+}
+function encodeLatin1(buffer) {
+    let result = '';
+    for (let i = 0; i < buffer.length; i++) {
+        result += String.fromCharCode(buffer[i]);
+    }
+    return result;
+}
+function detectEncodingFromBuffer({ buffer, bytesRead }, autoGuessEncoding) {
+    let encoding = detectEncodingByBOMFromBuffer(buffer, bytesRead);
+    let seemsBinary = false;
+    if (encoding !== UTF16be && encoding !== UTF16le && buffer) {
+        let couldBeUTF16LE = true;
+        let couldBeUTF16BE = true;
+        let containsZeroByte = false;
+        for (let i = 0; i < bytesRead && i < ZERO_BYTE_DETECTION_BUFFER_MAX_LEN; i++) {
+            const isEndian = (i % 2 === 1);
+            const isZeroByte = (buffer.readUInt8(i) === 0);
+            if (isZeroByte) {
+                containsZeroByte = true;
+            }
+            if (couldBeUTF16LE && (isEndian && !isZeroByte || !isEndian && isZeroByte)) {
+                couldBeUTF16LE = false;
+            }
+            if (couldBeUTF16BE && (isEndian && isZeroByte || !isEndian && !isZeroByte)) {
+                couldBeUTF16BE = false;
+            }
+            if (isZeroByte && !couldBeUTF16LE && !couldBeUTF16BE) {
+                break;
+            }
+        }
+        if (containsZeroByte) {
+            if (couldBeUTF16LE) {
+                encoding = UTF16le;
+            }
+            else if (couldBeUTF16BE) {
+                encoding = UTF16be;
+            }
+            else {
+                seemsBinary = true;
+            }
+        }
+    }
+    if (autoGuessEncoding && !seemsBinary && !encoding && buffer) {
+        return guessEncodingByBuffer(buffer.slice(0, bytesRead)).then(guessedEncoding => {
+            return {
+                seemsBinary: false,
+                encoding: guessedEncoding
+            };
+        });
+    }
+    return { seemsBinary, encoding };
+}
+let TextFileEditorModel = class TextFileEditorModel extends BaseTextEditorModel {
+    constructor(resource, preferredEncoding,
+    preferredLanguageId, languageService, modelService, fileService, textFileService, workingCopyBackupService, logService, workingCopyService, filesConfigurationService, labelService, languageDetectionService, accessibilityService, pathService, extensionService) {
+        super(modelService, languageService, languageDetectionService, accessibilityService);
+        this.resource = resource;
+        this.preferredEncoding = preferredEncoding;
+        this.preferredLanguageId = preferredLanguageId;
+        this.fileService = fileService;
+        this.textFileService = textFileService;
+        this.workingCopyBackupService = workingCopyBackupService;
+        this.logService = logService;
+        this.workingCopyService = workingCopyService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.labelService = labelService;
+        this.pathService = pathService;
+        this.extensionService = extensionService;
+        this._onDidChangeContent = this._register(( (new Emitter())));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this._onDidResolve = this._register(( (new Emitter())));
+        this.onDidResolve = this._onDidResolve.event;
+        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidSaveError = this._register(( (new Emitter())));
+        this.onDidSaveError = this._onDidSaveError.event;
+        this._onDidSave = this._register(( (new Emitter())));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( (new Emitter())));
+        this.onDidRevert = this._onDidRevert.event;
+        this._onDidChangeEncoding = this._register(( (new Emitter())));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this._onDidChangeOrphaned = this._register(( (new Emitter())));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidChangeReadonly = this._register(( (new Emitter())));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this.typeId = NO_TYPE_ID;
+        this.capabilities = 0 ;
+        this.name = basename(this.labelService.getUriLabel(this.resource));
+        this.resourceHasExtension = !!extUri.extname(this.resource);
+        this.versionId = 0;
+        this.ignoreDirtyOnModelContentChange = false;
+        this.ignoreSaveFromSaveParticipants = false;
+        this.lastModelContentChangeFromUndoRedo = undefined;
+        this.saveSequentializer = ( (new TaskSequentializer()));
+        this.dirty = false;
+        this.inConflictMode = false;
+        this.inOrphanMode = false;
+        this.inErrorMode = false;
+        this.hasEncodingSetExplicitly = false;
+        this._register(this.workingCopyService.registerWorkingCopy(this));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.filesConfigurationService.onFilesAssociationChange(() => this.onFilesAssociationChange()));
+    }
+    async onDidFilesChange(e) {
+        let fileEventImpactsModel = false;
+        let newInOrphanModeGuess;
+        if (this.inOrphanMode) {
+            const modelFileAdded = e.contains(this.resource, 1 );
+            if (modelFileAdded) {
+                newInOrphanModeGuess = false;
+                fileEventImpactsModel = true;
+            }
+        }
+        else {
+            const modelFileDeleted = e.contains(this.resource, 2 );
+            if (modelFileDeleted) {
+                newInOrphanModeGuess = true;
+                fileEventImpactsModel = true;
+            }
+        }
+        if (fileEventImpactsModel && this.inOrphanMode !== newInOrphanModeGuess) {
+            let newInOrphanModeValidated = false;
+            if (newInOrphanModeGuess) {
+                await timeout(100);
+                if (this.isDisposed()) {
+                    newInOrphanModeValidated = true;
+                }
+                else {
+                    const exists = await this.fileService.exists(this.resource);
+                    newInOrphanModeValidated = !exists;
+                }
+            }
+            if (this.inOrphanMode !== newInOrphanModeValidated && !this.isDisposed()) {
+                this.setOrphaned(newInOrphanModeValidated);
+            }
+        }
+    }
+    setOrphaned(orphaned) {
+        if (this.inOrphanMode !== orphaned) {
+            this.inOrphanMode = orphaned;
+            this._onDidChangeOrphaned.fire();
+        }
+    }
+    onFilesAssociationChange() {
+        if (!this.isResolved()) {
+            return;
+        }
+        const firstLineText = this.getFirstLineText(this.textEditorModel);
+        const languageSelection = this.getOrCreateLanguage(this.resource, this.languageService, this.preferredLanguageId, firstLineText);
+        this.modelService.setMode(this.textEditorModel, languageSelection);
+    }
+    setLanguageId(languageId, source) {
+        super.setLanguageId(languageId, source);
+        this.preferredLanguageId = languageId;
+    }
+    async backup(token) {
+        let meta = undefined;
+        if (this.lastResolvedFileStat) {
+            meta = {
+                mtime: this.lastResolvedFileStat.mtime,
+                ctime: this.lastResolvedFileStat.ctime,
+                size: this.lastResolvedFileStat.size,
+                etag: this.lastResolvedFileStat.etag,
+                orphaned: this.inOrphanMode
+            };
+        }
+        const content = await this.textFileService.getEncodedReadable(this.resource, withNullAsUndefined(this.createSnapshot()), { encoding: UTF8 });
+        return { meta, content };
+    }
+    async revert(options) {
+        if (!this.isResolved()) {
+            return;
+        }
+        const wasDirty = this.dirty;
+        const undo = this.doSetDirty(false);
+        const softUndo = options?.soft;
+        if (!softUndo) {
+            try {
+                await this.forceResolveFromFile();
+            }
+            catch (error) {
+                if (error.fileOperationResult !== 1 ) {
+                    undo();
+                    throw error;
+                }
+            }
+        }
+        this._onDidRevert.fire();
+        if (wasDirty) {
+            this._onDidChangeDirty.fire();
+        }
+    }
+    async resolve(options) {
+        this.trace('resolve() - enter');
+        if (this.isDisposed()) {
+            this.trace('resolve() - exit - without resolving because model is disposed');
+            return;
+        }
+        if (!options?.contents && (this.dirty || this.saveSequentializer.hasPending())) {
+            this.trace('resolve() - exit - without resolving because model is dirty or being saved');
+            return;
+        }
+        return this.doResolve(options);
+    }
+    async doResolve(options) {
+        if (options?.contents) {
+            return this.resolveFromBuffer(options.contents, options);
+        }
+        const isNewModel = !this.isResolved();
+        if (isNewModel) {
+            const resolvedFromBackup = await this.resolveFromBackup(options);
+            if (resolvedFromBackup) {
+                return;
+            }
+        }
+        return this.resolveFromFile(options);
+    }
+    async resolveFromBuffer(buffer, options) {
+        this.trace('resolveFromBuffer()');
+        let mtime;
+        let ctime;
+        let size;
+        let etag;
+        try {
+            const metadata = await this.fileService.stat(this.resource);
+            mtime = metadata.mtime;
+            ctime = metadata.ctime;
+            size = metadata.size;
+            etag = metadata.etag;
+            this.setOrphaned(false);
+        }
+        catch (error) {
+            mtime = Date.now();
+            ctime = Date.now();
+            size = 0;
+            etag = ETAG_DISABLED;
+            this.setOrphaned(error.fileOperationResult === 1 );
+        }
+        const preferredEncoding = await this.textFileService.encoding.getPreferredWriteEncoding(this.resource, this.preferredEncoding);
+        this.resolveFromContent({
+            resource: this.resource,
+            name: this.name,
+            mtime,
+            ctime,
+            size,
+            etag,
+            value: buffer,
+            encoding: preferredEncoding.encoding,
+            readonly: false
+        }, true , options);
+    }
+    async resolveFromBackup(options) {
+        const backup = await this.workingCopyBackupService.resolve(this);
+        let encoding = UTF8;
+        if (backup) {
+            encoding = (await this.textFileService.encoding.getPreferredWriteEncoding(this.resource, this.preferredEncoding)).encoding;
+        }
+        const isNewModel = !this.isResolved();
+        if (!isNewModel) {
+            this.trace('resolveFromBackup() - exit - without resolving because previously new model got created meanwhile');
+            return true;
+        }
+        if (backup) {
+            await this.doResolveFromBackup(backup, encoding, options);
+            return true;
+        }
+        return false;
+    }
+    async doResolveFromBackup(backup, encoding, options) {
+        this.trace('doResolveFromBackup()');
+        this.resolveFromContent({
+            resource: this.resource,
+            name: this.name,
+            mtime: backup.meta ? backup.meta.mtime : Date.now(),
+            ctime: backup.meta ? backup.meta.ctime : Date.now(),
+            size: backup.meta ? backup.meta.size : 0,
+            etag: backup.meta ? backup.meta.etag : ETAG_DISABLED,
+            value: await createTextBufferFactoryFromStream(await this.textFileService.getDecodedStream(this.resource, backup.value, { encoding: UTF8 })),
+            encoding,
+            readonly: false
+        }, true , options);
+        if (backup.meta?.orphaned) {
+            this.setOrphaned(true);
+        }
+    }
+    async resolveFromFile(options) {
+        this.trace('resolveFromFile()');
+        const forceReadFromFile = options?.forceReadFromFile;
+        const allowBinary = this.isResolved()  || options?.allowBinary;
+        let etag;
+        if (forceReadFromFile) {
+            etag = ETAG_DISABLED;
+        }
+        else if (this.lastResolvedFileStat) {
+            etag = this.lastResolvedFileStat.etag;
+        }
+        const currentVersionId = this.versionId;
+        try {
+            const content = await this.textFileService.readStream(this.resource, {
+                acceptTextOnly: !allowBinary,
+                etag, encoding: this.preferredEncoding,
+                limits: options?.limits
+            });
+            this.setOrphaned(false);
+            if (currentVersionId !== this.versionId) {
+                this.trace('resolveFromFile() - exit - without resolving because model content changed');
+                return;
+            }
+            return this.resolveFromContent(content, false , options);
+        }
+        catch (error) {
+            const result = error.fileOperationResult;
+            this.setOrphaned(result === 1 );
+            if (this.isResolved() && result === 2 ) {
+                if (error instanceof NotModifiedSinceFileOperationError) {
+                    this.updateLastResolvedFileStat(error.stat);
+                }
+                return;
+            }
+            if (this.isResolved() && result === 1  && !forceReadFromFile) {
+                return;
+            }
+            throw error;
+        }
+    }
+    resolveFromContent(content, dirty, options) {
+        this.trace('resolveFromContent() - enter');
+        if (this.isDisposed()) {
+            this.trace('resolveFromContent() - exit - because model is disposed');
+            return;
+        }
+        this.updateLastResolvedFileStat({
+            resource: this.resource,
+            name: content.name,
+            mtime: content.mtime,
+            ctime: content.ctime,
+            size: content.size,
+            etag: content.etag,
+            readonly: content.readonly,
+            isFile: true,
+            isDirectory: false,
+            isSymbolicLink: false,
+            children: undefined
+        });
+        const oldEncoding = this.contentEncoding;
+        this.contentEncoding = content.encoding;
+        if (this.preferredEncoding) {
+            this.updatePreferredEncoding(this.contentEncoding);
+        }
+        else if (oldEncoding !== this.contentEncoding) {
+            this._onDidChangeEncoding.fire();
+        }
+        if (this.textEditorModel) {
+            this.doUpdateTextModel(content.value);
+        }
+        else {
+            this.doCreateTextModel(content.resource, content.value);
+        }
+        this.setDirty(!!dirty);
+        this._onDidResolve.fire(options?.reason ?? 3 );
+    }
+    doCreateTextModel(resource, value) {
+        this.trace('doCreateTextModel()');
+        const textModel = this.createTextEditorModel(value, resource, this.preferredLanguageId);
+        this.installModelListeners(textModel);
+        this.autoDetectLanguage();
+    }
+    doUpdateTextModel(value) {
+        this.trace('doUpdateTextModel()');
+        this.ignoreDirtyOnModelContentChange = true;
+        try {
+            this.updateTextEditorModel(value, this.preferredLanguageId);
+        }
+        finally {
+            this.ignoreDirtyOnModelContentChange = false;
+        }
+    }
+    installModelListeners(model) {
+        this._register(model.onDidChangeContent(e => this.onModelContentChanged(model, e.isUndoing || e.isRedoing)));
+        this._register(model.onDidChangeLanguage(() => this.onMaybeShouldChangeEncoding()));
+        super.installModelListeners(model);
+    }
+    onModelContentChanged(model, isUndoingOrRedoing) {
+        this.trace(`onModelContentChanged() - enter`);
+        this.versionId++;
+        this.trace(`onModelContentChanged() - new versionId ${this.versionId}`);
+        if (isUndoingOrRedoing) {
+            this.lastModelContentChangeFromUndoRedo = Date.now();
+        }
+        if (!this.ignoreDirtyOnModelContentChange && !this.isReadonly()) {
+            if (model.getAlternativeVersionId() === this.bufferSavedVersionId) {
+                this.trace('onModelContentChanged() - model content changed back to last saved version');
+                const wasDirty = this.dirty;
+                this.setDirty(false);
+                if (wasDirty) {
+                    this._onDidRevert.fire();
+                }
+            }
+            else {
+                this.trace('onModelContentChanged() - model content changed and marked as dirty');
+                this.setDirty(true);
+            }
+        }
+        this._onDidChangeContent.fire();
+        this.autoDetectLanguage();
+    }
+    async autoDetectLanguage() {
+        await this.extensionService?.whenInstalledExtensionsRegistered();
+        const languageId = this.getLanguageId();
+        if (this.resource.scheme === this.pathService.defaultUriScheme &&
+            (!languageId || languageId === PLAINTEXT_LANGUAGE_ID) &&
+            !this.resourceHasExtension
+        ) {
+            return super.autoDetectLanguage();
+        }
+    }
+    async forceResolveFromFile() {
+        if (this.isDisposed()) {
+            return;
+        }
+        await this.textFileService.files.resolve(this.resource, {
+            reload: { async: false },
+            forceReadFromFile: true
+        });
+    }
+    isDirty() {
+        return this.dirty;
+    }
+    setDirty(dirty) {
+        if (!this.isResolved()) {
+            return;
+        }
+        const wasDirty = this.dirty;
+        this.doSetDirty(dirty);
+        if (dirty !== wasDirty) {
+            this._onDidChangeDirty.fire();
+        }
+    }
+    doSetDirty(dirty) {
+        const wasDirty = this.dirty;
+        const wasInConflictMode = this.inConflictMode;
+        const wasInErrorMode = this.inErrorMode;
+        const oldBufferSavedVersionId = this.bufferSavedVersionId;
+        if (!dirty) {
+            this.dirty = false;
+            this.inConflictMode = false;
+            this.inErrorMode = false;
+            this.updateSavedVersionId();
+        }
+        else {
+            this.dirty = true;
+        }
+        return () => {
+            this.dirty = wasDirty;
+            this.inConflictMode = wasInConflictMode;
+            this.inErrorMode = wasInErrorMode;
+            this.bufferSavedVersionId = oldBufferSavedVersionId;
+        };
+    }
+    async save(options = Object.create(null)) {
+        if (!this.isResolved()) {
+            return false;
+        }
+        if (this.isReadonly()) {
+            this.trace('save() - ignoring request for readonly resource');
+            return false;
+        }
+        if ((this.hasState(3 ) || this.hasState(5 )) &&
+            ((options.reason === 2  || options.reason === 3  || options.reason === 4) )) {
+            this.trace('save() - ignoring auto save request for model that is in conflict or error');
+            return false;
+        }
+        this.trace('save() - enter');
+        await this.doSave(options);
+        this.trace('save() - exit');
+        return this.hasState(0 );
+    }
+    async doSave(options) {
+        if (typeof options.reason !== 'number') {
+            options.reason = 1 ;
+        }
+        let versionId = this.versionId;
+        this.trace(`doSave(${versionId}) - enter with versionId ${versionId}`);
+        if (this.ignoreSaveFromSaveParticipants) {
+            this.trace(`doSave(${versionId}) - exit - refusing to save() recursively from save participant`);
+            return;
+        }
+        if (this.saveSequentializer.hasPending(versionId)) {
+            this.trace(`doSave(${versionId}) - exit - found a pending save for versionId ${versionId}`);
+            return this.saveSequentializer.pending;
+        }
+        if (!options.force && !this.dirty) {
+            this.trace(`doSave(${versionId}) - exit - because not dirty and/or versionId is different (this.isDirty: ${this.dirty}, this.versionId: ${this.versionId})`);
+            return;
+        }
+        if (this.saveSequentializer.hasPending()) {
+            this.trace(`doSave(${versionId}) - exit - because busy saving`);
+            this.saveSequentializer.cancelPending();
+            return this.saveSequentializer.setNext(() => this.doSave(options));
+        }
+        if (this.isResolved()) {
+            this.textEditorModel.pushStackElement();
+        }
+        const saveCancellation = ( (new CancellationTokenSource()));
+        return this.saveSequentializer.setPending(versionId, (async () => {
+            if (this.isResolved() && !options.skipSaveParticipants) {
+                try {
+                    if (options.reason === 2  && typeof this.lastModelContentChangeFromUndoRedo === 'number') {
+                        const timeFromUndoRedoToSave = Date.now() - this.lastModelContentChangeFromUndoRedo;
+                        if (timeFromUndoRedoToSave < TextFileEditorModel.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD) {
+                            await timeout(TextFileEditorModel.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD - timeFromUndoRedoToSave);
+                        }
+                    }
+                    if (!saveCancellation.token.isCancellationRequested) {
+                        this.ignoreSaveFromSaveParticipants = true;
+                        try {
+                            await this.textFileService.files.runSaveParticipants(this, { reason: options.reason ?? 1  }, saveCancellation.token);
+                        }
+                        finally {
+                            this.ignoreSaveFromSaveParticipants = false;
+                        }
+                    }
+                }
+                catch (error) {
+                    this.logService.error(`[text file model] runSaveParticipants(${versionId}) - resulted in an error: ${( ( error.toString()))}`, ( (this.resource.toString())));
+                }
+            }
+            if (saveCancellation.token.isCancellationRequested) {
+                return;
+            }
+            else {
+                saveCancellation.dispose();
+            }
+            if (this.isDisposed()) {
+                return;
+            }
+            if (!this.isResolved()) {
+                return;
+            }
+            versionId = this.versionId;
+            this.inErrorMode = false;
+            this.trace(`doSave(${versionId}) - before write()`);
+            const lastResolvedFileStat = assertIsDefined(this.lastResolvedFileStat);
+            const resolvedTextFileEditorModel = this;
+            return this.saveSequentializer.setPending(versionId, (async () => {
+                try {
+                    const stat = await this.textFileService.write(lastResolvedFileStat.resource, resolvedTextFileEditorModel.createSnapshot(), {
+                        mtime: lastResolvedFileStat.mtime,
+                        encoding: this.getEncoding(),
+                        etag: (options.ignoreModifiedSince || !this.filesConfigurationService.preventSaveConflicts(lastResolvedFileStat.resource, resolvedTextFileEditorModel.getLanguageId())) ? ETAG_DISABLED : lastResolvedFileStat.etag,
+                        unlock: options.writeUnlock,
+                        writeElevated: options.writeElevated
+                    });
+                    this.handleSaveSuccess(stat, versionId, options);
+                }
+                catch (error) {
+                    this.handleSaveError(error, versionId, options);
+                }
+            })());
+        })(), () => saveCancellation.cancel());
+    }
+    handleSaveSuccess(stat, versionId, options) {
+        this.updateLastResolvedFileStat(stat);
+        if (versionId === this.versionId) {
+            this.trace(`handleSaveSuccess(${versionId}) - setting dirty to false because versionId did not change`);
+            this.setDirty(false);
+        }
+        else {
+            this.trace(`handleSaveSuccess(${versionId}) - not setting dirty to false because versionId did change meanwhile`);
+        }
+        this.setOrphaned(false);
+        this._onDidSave.fire({ reason: options.reason, stat, source: options.source });
+    }
+    handleSaveError(error, versionId, options) {
+        (options.ignoreErrorHandler ? this.logService.trace : this.logService.error).apply(this.logService, [`[text file model] handleSaveError(${versionId}) - exit - resulted in a save error: ${( ( error.toString()))}`, ( (this.resource.toString()))]);
+        if (options.ignoreErrorHandler) {
+            throw error;
+        }
+        this.setDirty(true);
+        this.inErrorMode = true;
+        if (error.fileOperationResult === 3 ) {
+            this.inConflictMode = true;
+        }
+        this.textFileService.files.saveErrorHandler.onSaveError(error, this);
+        this._onDidSaveError.fire();
+    }
+    updateSavedVersionId() {
+        if (this.isResolved()) {
+            this.bufferSavedVersionId = this.textEditorModel.getAlternativeVersionId();
+        }
+    }
+    updateLastResolvedFileStat(newFileStat) {
+        const oldReadonly = this.isReadonly();
+        if (!this.lastResolvedFileStat) {
+            this.lastResolvedFileStat = newFileStat;
+        }
+        else if (this.lastResolvedFileStat.mtime <= newFileStat.mtime) {
+            this.lastResolvedFileStat = newFileStat;
+        }
+        if (this.isReadonly() !== oldReadonly) {
+            this._onDidChangeReadonly.fire();
+        }
+    }
+    hasState(state) {
+        switch (state) {
+            case 3 :
+                return this.inConflictMode;
+            case 1 :
+                return this.dirty;
+            case 5 :
+                return this.inErrorMode;
+            case 4 :
+                return this.inOrphanMode;
+            case 2 :
+                return this.saveSequentializer.hasPending();
+            case 0 :
+                return !this.dirty;
+        }
+    }
+    async joinState(state) {
+        return this.saveSequentializer.pending;
+    }
+    getLanguageId() {
+        if (this.textEditorModel) {
+            return this.textEditorModel.getLanguageId();
+        }
+        return this.preferredLanguageId;
+    }
+    async onMaybeShouldChangeEncoding() {
+        if (this.hasEncodingSetExplicitly) {
+            this.trace('onMaybeShouldChangeEncoding() - ignoring because encoding was set explicitly');
+            return;
+        }
+        if (this.contentEncoding === UTF8_with_bom || this.contentEncoding === UTF16be || this.contentEncoding === UTF16le) {
+            this.trace('onMaybeShouldChangeEncoding() - ignoring because content encoding has a BOM');
+            return;
+        }
+        const { encoding } = await this.textFileService.encoding.getPreferredReadEncoding(this.resource);
+        if (typeof encoding !== 'string' || !this.isNewEncoding(encoding)) {
+            this.trace(`onMaybeShouldChangeEncoding() - ignoring because preferred encoding ${encoding} is not new`);
+            return;
+        }
+        if (this.isDirty()) {
+            this.trace('onMaybeShouldChangeEncoding() - ignoring because model is dirty');
+            return;
+        }
+        this.logService.info(`Adjusting encoding based on configured language override to '${encoding}' for ${( ( this.resource.toString(true)))}.`);
+        return this.setEncodingInternal(encoding, 1 );
+    }
+    setEncoding(encoding, mode) {
+        this.hasEncodingSetExplicitly = true;
+        return this.setEncodingInternal(encoding, mode);
+    }
+    async setEncodingInternal(encoding, mode) {
+        if (mode === 0 ) {
+            this.updatePreferredEncoding(encoding);
+            if (!this.isDirty()) {
+                this.versionId++;
+                this.setDirty(true);
+            }
+            if (!this.inConflictMode) {
+                await this.save({ source: TextFileEditorModel.TEXTFILE_SAVE_ENCODING_SOURCE });
+            }
+        }
+        else {
+            if (!this.isNewEncoding(encoding)) {
+                return;
+            }
+            if (this.isDirty() && !this.inConflictMode) {
+                await this.save();
+            }
+            this.updatePreferredEncoding(encoding);
+            await this.forceResolveFromFile();
+        }
+    }
+    updatePreferredEncoding(encoding) {
+        if (!this.isNewEncoding(encoding)) {
+            return;
+        }
+        this.preferredEncoding = encoding;
+        this._onDidChangeEncoding.fire();
+    }
+    isNewEncoding(encoding) {
+        if (this.preferredEncoding === encoding) {
+            return false;
+        }
+        if (!this.preferredEncoding && this.contentEncoding === encoding) {
+            return false;
+        }
+        return true;
+    }
+    getEncoding() {
+        return this.preferredEncoding || this.contentEncoding;
+    }
+    trace(msg) {
+        this.logService.trace(`[text file model] ${msg}`, ( (this.resource.toString())));
+    }
+    isResolved() {
+        return !!this.textEditorModel;
+    }
+    isReadonly() {
+        return this.lastResolvedFileStat?.readonly || this.fileService.hasCapability(this.resource, 2048 );
+    }
+    dispose() {
+        this.trace('dispose()');
+        this.inConflictMode = false;
+        this.inOrphanMode = false;
+        this.inErrorMode = false;
+        super.dispose();
+    }
+};
+TextFileEditorModel.TEXTFILE_SAVE_ENCODING_SOURCE = SaveSourceRegistry.registerSource('textFileEncoding.source', ( (localize('textFileCreate.source', "File Encoding Changed"))));
+TextFileEditorModel.UNDO_REDO_SAVE_PARTICIPANTS_AUTO_SAVE_THROTTLE_THRESHOLD = 500;
+TextFileEditorModel = ( (__decorate([
+    ( (__param(3, ILanguageService))),
+    ( (__param(4, IModelService))),
+    ( (__param(5, IFileService))),
+    ( (__param(6, ITextFileService))),
+    ( (__param(7, IWorkingCopyBackupService))),
+    ( (__param(8, ILogService))),
+    ( (__param(9, IWorkingCopyService))),
+    ( (__param(10, IFilesConfigurationService))),
+    ( (__param(11, ILabelService))),
+    ( (__param(12, ILanguageDetectionService))),
+    ( (__param(13, IAccessibilityService))),
+    ( (__param(14, IPathService))),
+    ( (__param(15, IExtensionService)))
+], TextFileEditorModel)));
+export { BaseTextEditorModel as B, NO_TYPE_ID as N, TextFileEditorModel as T, UTF8 as U, toDecodeStream as a, UTF16be as b, createTextBufferFactoryFromStream as c, UTF16le as d, UTF8_with_bom as e, encodingExists as f, toEncodeReadable as t };