@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/common/model/tokenizationTextModelPart.js

@@ -0,0 +1,489 @@
+import { equals } from '../../../base/common/arrays.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { BugIndicatingError, onUnexpectedError } from '../../../base/common/errors.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, MutableDisposable, DisposableMap } from '../../../base/common/lifecycle.js';
+import { countEOL } from '../core/eolCounter.js';
+import { LineRange } from '../core/lineRange.js';
+import { Position } from '../core/position.js';
+import { getWordAtText } from '../core/wordHelper.js';
+import { TokenizationRegistry } from '../languages.js';
+import { TextModelPart } from './textModelPart.js';
+import { TrackingTokenizationStateStore, TokenizerWithStateStoreAndTextModel, DefaultBackgroundTokenizer } from './textModelTokens.js';
+import { ContiguousMultilineTokensBuilder } from '../tokens/contiguousMultilineTokensBuilder.js';
+import { ContiguousTokensStore } from '../tokens/contiguousTokensStore.js';
+import { SparseTokensStore } from '../tokens/sparseTokensStore.js';
+class TokenizationTextModelPart extends TextModelPart {
+    constructor(_languageService, _languageConfigurationService, _textModel, _bracketPairsTextModelPart, _languageId, _attachedViews) {
+        super();
+        this._languageService = _languageService;
+        this._languageConfigurationService = _languageConfigurationService;
+        this._textModel = _textModel;
+        this._bracketPairsTextModelPart = _bracketPairsTextModelPart;
+        this._languageId = _languageId;
+        this._attachedViews = _attachedViews;
+        this._semanticTokens = ( new SparseTokensStore(this._languageService.languageIdCodec));
+        this._onDidChangeLanguage = this._register(( new Emitter()));
+        this.onDidChangeLanguage = this._onDidChangeLanguage.event;
+        this._onDidChangeLanguageConfiguration = this._register(( new Emitter()));
+        this.onDidChangeLanguageConfiguration = this._onDidChangeLanguageConfiguration.event;
+        this._onDidChangeTokens = this._register(( new Emitter()));
+        this.onDidChangeTokens = this._onDidChangeTokens.event;
+        this.grammarTokens = this._register(( new GrammarTokens(
+            this._languageService.languageIdCodec,
+            this._textModel,
+            () => this._languageId,
+            this._attachedViews
+        )));
+        this._register(this._languageConfigurationService.onDidChange(e => {
+            if (e.affects(this._languageId)) {
+                this._onDidChangeLanguageConfiguration.fire({});
+            }
+        }));
+        this._register(this.grammarTokens.onDidChangeTokens(e => {
+            this._emitModelTokensChangedEvent(e);
+        }));
+        this._register(this.grammarTokens.onDidChangeBackgroundTokenizationState(e => {
+            this._bracketPairsTextModelPart.handleDidChangeBackgroundTokenizationState();
+        }));
+    }
+    _hasListeners() {
+        return (this._onDidChangeLanguage.hasListeners()
+            || this._onDidChangeLanguageConfiguration.hasListeners()
+            || this._onDidChangeTokens.hasListeners());
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            this._semanticTokens.flush();
+        }
+        else if (!e.isEolChange) {
+            for (const c of e.changes) {
+                const [eolCount, firstLineLength, lastLineLength] = countEOL(c.text);
+                this._semanticTokens.acceptEdit(c.range, eolCount, firstLineLength, lastLineLength, c.text.length > 0 ? c.text.charCodeAt(0) : 0 );
+            }
+        }
+        this.grammarTokens.handleDidChangeContent(e);
+    }
+    handleDidChangeAttached() {
+        this.grammarTokens.handleDidChangeAttached();
+    }
+    getLineTokens(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        const syntacticTokens = this.grammarTokens.getLineTokens(lineNumber);
+        return this._semanticTokens.addSparseTokens(lineNumber, syntacticTokens);
+    }
+    _emitModelTokensChangedEvent(e) {
+        if (!this._textModel._isDisposing()) {
+            this._bracketPairsTextModelPart.handleDidChangeTokens(e);
+            this._onDidChangeTokens.fire(e);
+        }
+    }
+    validateLineNumber(lineNumber) {
+        if (lineNumber < 1 || lineNumber > this._textModel.getLineCount()) {
+            throw new BugIndicatingError('Illegal value for lineNumber');
+        }
+    }
+    get hasTokens() {
+        return this.grammarTokens.hasTokens;
+    }
+    resetTokenization() {
+        this.grammarTokens.resetTokenization();
+    }
+    get backgroundTokenizationState() {
+        return this.grammarTokens.backgroundTokenizationState;
+    }
+    forceTokenization(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        this.grammarTokens.forceTokenization(lineNumber);
+    }
+    isCheapToTokenize(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        return this.grammarTokens.isCheapToTokenize(lineNumber);
+    }
+    tokenizeIfCheap(lineNumber) {
+        this.validateLineNumber(lineNumber);
+        this.grammarTokens.tokenizeIfCheap(lineNumber);
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        return this.grammarTokens.getTokenTypeIfInsertingCharacter(lineNumber, column, character);
+    }
+    tokenizeLineWithEdit(position, length, newText) {
+        return this.grammarTokens.tokenizeLineWithEdit(position, length, newText);
+    }
+    setSemanticTokens(tokens, isComplete) {
+        this._semanticTokens.set(tokens, isComplete);
+        this._emitModelTokensChangedEvent({
+            semanticTokensApplied: tokens !== null,
+            ranges: [{ fromLineNumber: 1, toLineNumber: this._textModel.getLineCount() }],
+        });
+    }
+    hasCompleteSemanticTokens() {
+        return this._semanticTokens.isComplete();
+    }
+    hasSomeSemanticTokens() {
+        return !this._semanticTokens.isEmpty();
+    }
+    setPartialSemanticTokens(range, tokens) {
+        if (this.hasCompleteSemanticTokens()) {
+            return;
+        }
+        const changedRange = this._textModel.validateRange(this._semanticTokens.setPartial(range, tokens));
+        this._emitModelTokensChangedEvent({
+            semanticTokensApplied: true,
+            ranges: [
+                {
+                    fromLineNumber: changedRange.startLineNumber,
+                    toLineNumber: changedRange.endLineNumber,
+                },
+            ],
+        });
+    }
+    getWordAtPosition(_position) {
+        this.assertNotDisposed();
+        const position = this._textModel.validatePosition(_position);
+        const lineContent = this._textModel.getLineContent(position.lineNumber);
+        const lineTokens = this.getLineTokens(position.lineNumber);
+        const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);
+        const [rbStartOffset, rbEndOffset] = TokenizationTextModelPart._findLanguageBoundaries(lineTokens, tokenIndex);
+        const rightBiasedWord = getWordAtText(position.column, this.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex)).getWordDefinition(), lineContent.substring(rbStartOffset, rbEndOffset), rbStartOffset);
+        if (rightBiasedWord &&
+            rightBiasedWord.startColumn <= _position.column &&
+            _position.column <= rightBiasedWord.endColumn) {
+            return rightBiasedWord;
+        }
+        if (tokenIndex > 0 && rbStartOffset === position.column - 1) {
+            const [lbStartOffset, lbEndOffset] = TokenizationTextModelPart._findLanguageBoundaries(lineTokens, tokenIndex - 1);
+            const leftBiasedWord = getWordAtText(position.column, this.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex - 1)).getWordDefinition(), lineContent.substring(lbStartOffset, lbEndOffset), lbStartOffset);
+            if (leftBiasedWord &&
+                leftBiasedWord.startColumn <= _position.column &&
+                _position.column <= leftBiasedWord.endColumn) {
+                return leftBiasedWord;
+            }
+        }
+        return null;
+    }
+    getLanguageConfiguration(languageId) {
+        return this._languageConfigurationService.getLanguageConfiguration(languageId);
+    }
+    static _findLanguageBoundaries(lineTokens, tokenIndex) {
+        const languageId = lineTokens.getLanguageId(tokenIndex);
+        let startOffset = 0;
+        for (let i = tokenIndex; i >= 0 && lineTokens.getLanguageId(i) === languageId; i--) {
+            startOffset = lineTokens.getStartOffset(i);
+        }
+        let endOffset = lineTokens.getLineContent().length;
+        for (let i = tokenIndex, tokenCount = lineTokens.getCount(); i < tokenCount && lineTokens.getLanguageId(i) === languageId; i++) {
+            endOffset = lineTokens.getEndOffset(i);
+        }
+        return [startOffset, endOffset];
+    }
+    getWordUntilPosition(position) {
+        const wordAtPosition = this.getWordAtPosition(position);
+        if (!wordAtPosition) {
+            return { word: '', startColumn: position.column, endColumn: position.column, };
+        }
+        return {
+            word: wordAtPosition.word.substr(0, position.column - wordAtPosition.startColumn),
+            startColumn: wordAtPosition.startColumn,
+            endColumn: position.column,
+        };
+    }
+    getLanguageId() {
+        return this._languageId;
+    }
+    getLanguageIdAtPosition(lineNumber, column) {
+        const position = this._textModel.validatePosition(( new Position(lineNumber, column)));
+        const lineTokens = this.getLineTokens(position.lineNumber);
+        return lineTokens.getLanguageId(lineTokens.findTokenIndexAtOffset(position.column - 1));
+    }
+    setLanguageId(languageId, source = 'api') {
+        if (this._languageId === languageId) {
+            return;
+        }
+        const e = {
+            oldLanguage: this._languageId,
+            newLanguage: languageId,
+            source
+        };
+        this._languageId = languageId;
+        this._bracketPairsTextModelPart.handleDidChangeLanguage(e);
+        this.grammarTokens.resetTokenization();
+        this._onDidChangeLanguage.fire(e);
+        this._onDidChangeLanguageConfiguration.fire({});
+    }
+}
+class GrammarTokens extends Disposable {
+    get backgroundTokenizationState() {
+        return this._backgroundTokenizationState;
+    }
+    constructor(_languageIdCodec, _textModel, getLanguageId, attachedViews) {
+        super();
+        this._languageIdCodec = _languageIdCodec;
+        this._textModel = _textModel;
+        this.getLanguageId = getLanguageId;
+        this._tokenizer = null;
+        this._defaultBackgroundTokenizer = null;
+        this._backgroundTokenizer = this._register(( new MutableDisposable()));
+        this._tokens = ( new ContiguousTokensStore(this._languageIdCodec));
+        this._debugBackgroundTokenizer = this._register(( new MutableDisposable()));
+        this._backgroundTokenizationState = 1 ;
+        this._onDidChangeBackgroundTokenizationState = this._register(( new Emitter()));
+        this.onDidChangeBackgroundTokenizationState = this._onDidChangeBackgroundTokenizationState.event;
+        this._onDidChangeTokens = this._register(( new Emitter()));
+        this.onDidChangeTokens = this._onDidChangeTokens.event;
+        this._attachedViewStates = this._register(( new DisposableMap()));
+        this._register(TokenizationRegistry.onDidChange((e) => {
+            const languageId = this.getLanguageId();
+            if (e.changedLanguages.indexOf(languageId) === -1) {
+                return;
+            }
+            this.resetTokenization();
+        }));
+        this.resetTokenization();
+        this._register(attachedViews.onDidChangeVisibleRanges(({ view, state }) => {
+            if (state) {
+                let existing = this._attachedViewStates.get(view);
+                if (!existing) {
+                    existing = ( new AttachedViewHandler(() => this.refreshRanges(existing.lineRanges)));
+                    this._attachedViewStates.set(view, existing);
+                }
+                existing.handleStateChange(state);
+            }
+            else {
+                this._attachedViewStates.deleteAndDispose(view);
+            }
+        }));
+    }
+    resetTokenization(fireTokenChangeEvent = true) {
+        this._tokens.flush();
+        this._debugBackgroundTokens?.flush();
+        if (this._debugBackgroundStates) {
+            this._debugBackgroundStates = ( new TrackingTokenizationStateStore(this._textModel.getLineCount()));
+        }
+        if (fireTokenChangeEvent) {
+            this._onDidChangeTokens.fire({
+                semanticTokensApplied: false,
+                ranges: [
+                    {
+                        fromLineNumber: 1,
+                        toLineNumber: this._textModel.getLineCount(),
+                    },
+                ],
+            });
+        }
+        const initializeTokenization = () => {
+            if (this._textModel.isTooLargeForTokenization()) {
+                return [null, null];
+            }
+            const tokenizationSupport = TokenizationRegistry.get(this.getLanguageId());
+            if (!tokenizationSupport) {
+                return [null, null];
+            }
+            let initialState;
+            try {
+                initialState = tokenizationSupport.getInitialState();
+            }
+            catch (e) {
+                onUnexpectedError(e);
+                return [null, null];
+            }
+            return [tokenizationSupport, initialState];
+        };
+        const [tokenizationSupport, initialState] = initializeTokenization();
+        if (tokenizationSupport && initialState) {
+            this._tokenizer = ( new TokenizerWithStateStoreAndTextModel(
+                this._textModel.getLineCount(),
+                tokenizationSupport,
+                this._textModel,
+                this._languageIdCodec
+            ));
+        }
+        else {
+            this._tokenizer = null;
+        }
+        this._backgroundTokenizer.clear();
+        this._defaultBackgroundTokenizer = null;
+        if (this._tokenizer) {
+            const b = {
+                setTokens: (tokens) => {
+                    this.setTokens(tokens);
+                },
+                backgroundTokenizationFinished: () => {
+                    if (this._backgroundTokenizationState === 2 ) {
+                        return;
+                    }
+                    const newState = 2 ;
+                    this._backgroundTokenizationState = newState;
+                    this._onDidChangeBackgroundTokenizationState.fire();
+                },
+                setEndState: (lineNumber, state) => {
+                    if (!this._tokenizer) {
+                        return;
+                    }
+                    const firstInvalidEndStateLineNumber = this._tokenizer.store.getFirstInvalidEndStateLineNumber();
+                    if (firstInvalidEndStateLineNumber !== null && lineNumber >= firstInvalidEndStateLineNumber) {
+                        this._tokenizer?.store.setEndState(lineNumber, state);
+                    }
+                },
+            };
+            if (tokenizationSupport && tokenizationSupport.createBackgroundTokenizer && !tokenizationSupport.backgroundTokenizerShouldOnlyVerifyTokens) {
+                this._backgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, b);
+            }
+            if (!this._backgroundTokenizer.value) {
+                this._backgroundTokenizer.value = this._defaultBackgroundTokenizer =
+                    ( new DefaultBackgroundTokenizer(this._tokenizer, b));
+                this._defaultBackgroundTokenizer.handleChanges();
+            }
+            if (tokenizationSupport?.backgroundTokenizerShouldOnlyVerifyTokens && tokenizationSupport.createBackgroundTokenizer) {
+                this._debugBackgroundTokens = ( new ContiguousTokensStore(this._languageIdCodec));
+                this._debugBackgroundStates = ( new TrackingTokenizationStateStore(this._textModel.getLineCount()));
+                this._debugBackgroundTokenizer.clear();
+                this._debugBackgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, {
+                    setTokens: (tokens) => {
+                        this._debugBackgroundTokens?.setMultilineTokens(tokens, this._textModel);
+                    },
+                    backgroundTokenizationFinished() {
+                    },
+                    setEndState: (lineNumber, state) => {
+                        this._debugBackgroundStates?.setEndState(lineNumber, state);
+                    },
+                });
+            }
+            else {
+                this._debugBackgroundTokens = undefined;
+                this._debugBackgroundStates = undefined;
+                this._debugBackgroundTokenizer.value = undefined;
+            }
+        }
+        this.refreshAllVisibleLineTokens();
+    }
+    handleDidChangeAttached() {
+        this._defaultBackgroundTokenizer?.handleChanges();
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            this.resetTokenization(false);
+        }
+        else if (!e.isEolChange) {
+            for (const c of e.changes) {
+                const [eolCount, firstLineLength] = countEOL(c.text);
+                this._tokens.acceptEdit(c.range, eolCount, firstLineLength);
+                this._debugBackgroundTokens?.acceptEdit(c.range, eolCount, firstLineLength);
+            }
+            this._debugBackgroundStates?.acceptChanges(e.changes);
+            if (this._tokenizer) {
+                this._tokenizer.store.acceptChanges(e.changes);
+            }
+            this._defaultBackgroundTokenizer?.handleChanges();
+        }
+    }
+    setTokens(tokens) {
+        const { changes } = this._tokens.setMultilineTokens(tokens, this._textModel);
+        if (changes.length > 0) {
+            this._onDidChangeTokens.fire({ semanticTokensApplied: false, ranges: changes, });
+        }
+        return { changes: changes };
+    }
+    refreshAllVisibleLineTokens() {
+        const ranges = LineRange.joinMany(( [...this._attachedViewStates].map(([_, s]) => s.lineRanges)));
+        this.refreshRanges(ranges);
+    }
+    refreshRanges(ranges) {
+        for (const range of ranges) {
+            this.refreshRange(range.startLineNumber, range.endLineNumberExclusive - 1);
+        }
+    }
+    refreshRange(startLineNumber, endLineNumber) {
+        if (!this._tokenizer) {
+            return;
+        }
+        startLineNumber = Math.max(1, Math.min(this._textModel.getLineCount(), startLineNumber));
+        endLineNumber = Math.min(this._textModel.getLineCount(), endLineNumber);
+        const builder = ( new ContiguousMultilineTokensBuilder());
+        const { heuristicTokens } = this._tokenizer.tokenizeHeuristically(builder, startLineNumber, endLineNumber);
+        const changedTokens = this.setTokens(builder.finalize());
+        if (heuristicTokens) {
+            for (const c of changedTokens.changes) {
+                this._backgroundTokenizer.value?.requestTokens(c.fromLineNumber, c.toLineNumber + 1);
+            }
+        }
+        this._defaultBackgroundTokenizer?.checkFinished();
+    }
+    forceTokenization(lineNumber) {
+        const builder = ( new ContiguousMultilineTokensBuilder());
+        this._tokenizer?.updateTokensUntilLine(builder, lineNumber);
+        this.setTokens(builder.finalize());
+        this._defaultBackgroundTokenizer?.checkFinished();
+    }
+    isCheapToTokenize(lineNumber) {
+        if (!this._tokenizer) {
+            return true;
+        }
+        return this._tokenizer.isCheapToTokenize(lineNumber);
+    }
+    tokenizeIfCheap(lineNumber) {
+        if (this.isCheapToTokenize(lineNumber)) {
+            this.forceTokenization(lineNumber);
+        }
+    }
+    getLineTokens(lineNumber) {
+        const lineText = this._textModel.getLineContent(lineNumber);
+        const result = this._tokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);
+        if (this._debugBackgroundTokens && this._debugBackgroundStates && this._tokenizer) {
+            if (this._debugBackgroundStates.getFirstInvalidEndStateLineNumberOrMax() > lineNumber && this._tokenizer.store.getFirstInvalidEndStateLineNumberOrMax() > lineNumber) {
+                const backgroundResult = this._debugBackgroundTokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);
+                if (!result.equals(backgroundResult) && this._debugBackgroundTokenizer.value?.reportMismatchingTokens) {
+                    this._debugBackgroundTokenizer.value.reportMismatchingTokens(lineNumber);
+                }
+            }
+        }
+        return result;
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        if (!this._tokenizer) {
+            return 0 ;
+        }
+        const position = this._textModel.validatePosition(( new Position(lineNumber, column)));
+        this.forceTokenization(position.lineNumber);
+        return this._tokenizer.getTokenTypeIfInsertingCharacter(position, character);
+    }
+    tokenizeLineWithEdit(position, length, newText) {
+        if (!this._tokenizer) {
+            return null;
+        }
+        const validatedPosition = this._textModel.validatePosition(position);
+        this.forceTokenization(validatedPosition.lineNumber);
+        return this._tokenizer.tokenizeLineWithEdit(validatedPosition, length, newText);
+    }
+    get hasTokens() {
+        return this._tokens.hasTokens;
+    }
+}
+class AttachedViewHandler extends Disposable {
+    get lineRanges() { return this._lineRanges; }
+    constructor(_refreshTokens) {
+        super();
+        this._refreshTokens = _refreshTokens;
+        this.runner = this._register(( new RunOnceScheduler(() => this.update(), 50)));
+        this._computedLineRanges = [];
+        this._lineRanges = [];
+    }
+    update() {
+        if (equals(this._computedLineRanges, this._lineRanges, (a, b) => a.equals(b))) {
+            return;
+        }
+        this._computedLineRanges = this._lineRanges;
+        this._refreshTokens();
+    }
+    handleStateChange(state) {
+        this._lineRanges = state.visibleLineRanges;
+        if (state.stabilized) {
+            this.runner.cancel();
+            this.update();
+        }
+        else {
+            this.runner.schedule();
+        }
+    }
+}
+export { TokenizationTextModelPart };

package/vscode/src/vs/editor/common/model/utils.js

@@ -0,0 +1,23 @@
+function computeIndentLevel(line, tabSize) {
+    let indent = 0;
+    let i = 0;
+    const len = line.length;
+    while (i < len) {
+        const chCode = line.charCodeAt(i);
+        if (chCode === 32 ) {
+            indent++;
+        }
+        else if (chCode === 9 ) {
+            indent = indent - indent % tabSize + tabSize;
+        }
+        else {
+            break;
+        }
+        i++;
+    }
+    if (i === len) {
+        return -1;
+    }
+    return indent;
+}
+export { computeIndentLevel };

package/vscode/src/vs/editor/common/model.d.ts

@@ -1,8 +1,8 @@
+import { editor } from '../editor.api.js';
 import { Event } from '../../base/common/event.js';
 import { IMarkdownString } from '../../base/common/htmlContent.js';
 import { IDisposable } from '../../base/common/lifecycle.js';
 import { ThemeColor } from '../../base/common/themables.js';
-import * as monaco from 'monaco-editor';
 import { ISingleEditOperation } from './core/editOperation.js';
 import { Position } from './core/position.js';
 import { Range, IRange } from './core/range.js';
@@ -423,7 +423,7 @@ interface ITextSnapshot {
 /**
  * A model.
  */
-type ITextModel = monaco.editor.ITextModel
+type ITextModel = editor.ITextModel
 /**
  * @internal
  */

package/vscode/src/vs/editor/common/model.js

@@ -0,0 +1,101 @@
+import { equals } from '../../base/common/objects.js';
+var OverviewRulerLane;
+( (function(OverviewRulerLane) {
+    OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";
+    OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";
+    OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";
+    OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";
+})(OverviewRulerLane || (OverviewRulerLane = {})));
+var GlyphMarginLane;
+( (function(GlyphMarginLane) {
+    GlyphMarginLane[GlyphMarginLane["Left"] = 1] = "Left";
+    GlyphMarginLane[GlyphMarginLane["Right"] = 2] = "Right";
+})(GlyphMarginLane || (GlyphMarginLane = {})));
+var MinimapPosition;
+( (function(MinimapPosition) {
+    MinimapPosition[MinimapPosition["Inline"] = 1] = "Inline";
+    MinimapPosition[MinimapPosition["Gutter"] = 2] = "Gutter";
+})(MinimapPosition || (MinimapPosition = {})));
+var InjectedTextCursorStops;
+( (function(InjectedTextCursorStops) {
+    InjectedTextCursorStops[InjectedTextCursorStops["Both"] = 0] = "Both";
+    InjectedTextCursorStops[InjectedTextCursorStops["Right"] = 1] = "Right";
+    InjectedTextCursorStops[InjectedTextCursorStops["Left"] = 2] = "Left";
+    InjectedTextCursorStops[InjectedTextCursorStops["None"] = 3] = "None";
+})(InjectedTextCursorStops || (InjectedTextCursorStops = {})));
+class TextModelResolvedOptions {
+    get originalIndentSize() {
+        return this._indentSizeIsTabSize ? 'tabSize' : this.indentSize;
+    }
+    constructor(src) {
+        this._textModelResolvedOptionsBrand = undefined;
+        this.tabSize = Math.max(1, src.tabSize | 0);
+        if (src.indentSize === 'tabSize') {
+            this.indentSize = this.tabSize;
+            this._indentSizeIsTabSize = true;
+        }
+        else {
+            this.indentSize = Math.max(1, src.indentSize | 0);
+            this._indentSizeIsTabSize = false;
+        }
+        this.insertSpaces = Boolean(src.insertSpaces);
+        this.defaultEOL = src.defaultEOL | 0;
+        this.trimAutoWhitespace = Boolean(src.trimAutoWhitespace);
+        this.bracketPairColorizationOptions = src.bracketPairColorizationOptions;
+    }
+    equals(other) {
+        return (this.tabSize === other.tabSize
+            && this._indentSizeIsTabSize === other._indentSizeIsTabSize
+            && this.indentSize === other.indentSize
+            && this.insertSpaces === other.insertSpaces
+            && this.defaultEOL === other.defaultEOL
+            && this.trimAutoWhitespace === other.trimAutoWhitespace
+            && equals(this.bracketPairColorizationOptions, other.bracketPairColorizationOptions));
+    }
+    createChangeEvent(newOpts) {
+        return {
+            tabSize: this.tabSize !== newOpts.tabSize,
+            indentSize: this.indentSize !== newOpts.indentSize,
+            insertSpaces: this.insertSpaces !== newOpts.insertSpaces,
+            trimAutoWhitespace: this.trimAutoWhitespace !== newOpts.trimAutoWhitespace,
+        };
+    }
+}
+class FindMatch {
+    constructor(range, matches) {
+        this._findMatchBrand = undefined;
+        this.range = range;
+        this.matches = matches;
+    }
+}
+function isITextSnapshot(obj) {
+    return (obj && typeof obj.read === 'function');
+}
+class ValidAnnotatedEditOperation {
+    constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) {
+        this.identifier = identifier;
+        this.range = range;
+        this.text = text;
+        this.forceMoveMarkers = forceMoveMarkers;
+        this.isAutoWhitespaceEdit = isAutoWhitespaceEdit;
+        this._isTracked = _isTracked;
+    }
+}
+class SearchData {
+    constructor(regex, wordSeparators, simpleSearch) {
+        this.regex = regex;
+        this.wordSeparators = wordSeparators;
+        this.simpleSearch = simpleSearch;
+    }
+}
+class ApplyEditsResult {
+    constructor(reverseEdits, changes, trimAutoWhitespaceLineNumbers) {
+        this.reverseEdits = reverseEdits;
+        this.changes = changes;
+        this.trimAutoWhitespaceLineNumbers = trimAutoWhitespaceLineNumbers;
+    }
+}
+function shouldSynchronizeModel(model) {
+    return (!model.isTooLargeForSyncing() && !model.isForSimpleWidget);
+}
+export { ApplyEditsResult, FindMatch, GlyphMarginLane, InjectedTextCursorStops, MinimapPosition, OverviewRulerLane, SearchData, TextModelResolvedOptions, ValidAnnotatedEditOperation, isITextSnapshot, shouldSynchronizeModel };