@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

package/dist/vscode/vs/workbench/services/hover/browser/hoverService.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/hover.css";
+import './media/hover.css.js';
 import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { editorHoverBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';

package/dist/vscode/vs/workbench/services/hover/browser/media/hover.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .workbench-hover{background:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);box-shadow:0 2px 8px var(--vscode-widget-shadow);color:var(--vscode-editorHoverWidget-foreground);font-size:13px;line-height:19px;max-width:700px;overflow:hidden;position:relative;z-index:40}.monaco-workbench .workbench-hover hr{border-bottom:none}.monaco-workbench .workbench-hover:not(.skip-fade-in){animation:fadein .1s linear}.monaco-workbench .workbench-hover.compact{font-size:12px}.monaco-workbench .workbench-hover.compact .hover-contents{padding:2px 8px}.monaco-workbench .workbench-hover-container.locked .workbench-hover{outline:1px solid var(--vscode-editorHoverWidget-border)}.monaco-workbench .workbench-hover-container.locked .workbench-hover:focus,.monaco-workbench .workbench-hover-lock:focus{outline:1px solid var(--vscode-focusBorder)}.monaco-workbench .workbench-hover-container.locked .workbench-hover-lock:hover{background:var(--vscode-toolbar-hoverBackground)}.monaco-workbench .workbench-hover-pointer{pointer-events:none;position:absolute;z-index:41}.monaco-workbench .workbench-hover-pointer:after{background-color:var(--vscode-editorHoverWidget-background);border-bottom:1px solid var(--vscode-editorHoverWidget-border);border-right:1px solid var(--vscode-editorHoverWidget-border);content:\"\";height:5px;position:absolute;width:5px}.monaco-workbench .locked .workbench-hover-pointer:after{border-bottom-width:2px;border-right-width:2px;height:4px;width:4px}.monaco-workbench .workbench-hover-pointer.left{left:-3px}.monaco-workbench .workbench-hover-pointer.right{right:3px}.monaco-workbench .workbench-hover-pointer.top{top:-3px}.monaco-workbench .workbench-hover-pointer.bottom{bottom:3px}.monaco-workbench .workbench-hover-pointer.left:after{transform:rotate(135deg)}.monaco-workbench .workbench-hover-pointer.right:after{transform:rotate(315deg)}.monaco-workbench .workbench-hover-pointer.top:after{transform:rotate(225deg)}.monaco-workbench .workbench-hover-pointer.bottom:after{transform:rotate(45deg)}.monaco-workbench .workbench-hover a{color:var(--vscode-textLink-foreground)}.monaco-workbench .workbench-hover a:focus{outline:1px solid;outline-color:var(--vscode-focusBorder);outline-offset:-1px;text-decoration:underline}.monaco-workbench .workbench-hover a:active,.monaco-workbench .workbench-hover a:hover{color:var(--vscode-textLink-activeForeground)}.monaco-workbench .workbench-hover code{background:var(--vscode-textCodeBlock-background)}.monaco-workbench .workbench-hover .hover-row .actions{background:var(--vscode-editorHoverWidget-statusBarBackground)}.monaco-workbench .workbench-hover.right-aligned{left:1px}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions{flex-direction:row-reverse}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container{margin-left:16px;margin-right:0}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.js

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const ILanguageDetectionService = ( createDecorator('ILanguageDetectionService'));
 const LanguageDetectionLanguageEventSource = 'languageDetection';
-export { ILanguageDetectionService, LanguageDetectionLanguageEventSource };
+const AutomaticLanguageDetectionLikelyWrongId = 'automaticlanguagedetection.likelywrong';
+export { AutomaticLanguageDetectionLikelyWrongId, ILanguageDetectionService, LanguageDetectionLanguageEventSource };

package/dist/vscode/vs/workbench/services/outline/browser/outline.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IOutlineService = ( createDecorator('IOutlineService'));
+export { IOutlineService };

package/dist/vscode/vs/workbench/services/progress/browser/progressIndicator.js

@@ -1,5 +1,76 @@
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { emptyProgressRunner } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+class EditorProgressIndicator extends Disposable {
+    constructor(progressBar, group) {
+        super();
+        this.progressBar = progressBar;
+        this.group = group;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.group.onDidModelChange(e => {
+            if (e.kind === 6  ||
+                (e.kind === 4  && this.group.isEmpty)) {
+                this.progressBar.stop().hide();
+            }
+        }));
+    }
+    show(infiniteOrTotal, delay) {
+        if (this.group.isEmpty) {
+            return emptyProgressRunner;
+        }
+        if (infiniteOrTotal === true) {
+            return this.doShow(true, delay);
+        }
+        return this.doShow(infiniteOrTotal, delay);
+    }
+    doShow(infiniteOrTotal, delay) {
+        if (typeof infiniteOrTotal === 'boolean') {
+            this.progressBar.infinite().show(delay);
+        }
+        else {
+            this.progressBar.total(infiniteOrTotal).show(delay);
+        }
+        return {
+            total: (total) => {
+                this.progressBar.total(total);
+            },
+            worked: (worked) => {
+                if (this.progressBar.hasTotal()) {
+                    this.progressBar.worked(worked);
+                }
+                else {
+                    this.progressBar.infinite().show();
+                }
+            },
+            done: () => {
+                this.progressBar.stop().hide();
+            }
+        };
+    }
+    async showWhile(promise, delay) {
+        if (this.group.isEmpty) {
+            try {
+                await promise;
+            }
+            catch (error) {
+            }
+        }
+        return this.doShowWhile(promise, delay);
+    }
+    async doShowWhile(promise, delay) {
+        try {
+            this.progressBar.infinite().show(delay);
+            await promise;
+        }
+        catch (error) {
+        }
+        finally {
+            this.progressBar.stop().hide();
+        }
+    }
+}
 var ProgressIndicatorState;
 ( (function(ProgressIndicatorState) {
     ( (function(Type) {
@@ -171,4 +242,4 @@ class AbstractProgressScope extends Disposable {
         }
     }
 }
-export { AbstractProgressScope, ScopedProgressIndicator };
+export { AbstractProgressScope, EditorProgressIndicator, ScopedProgressIndicator };

package/dist/vscode/vs/workbench/services/quickinput/browser/quickInputService.js

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { QuickInputService as QuickInputService$1 } from 'monaco-editor/esm/vs/platform/quickinput/browser/quickInputService.js';
+import { InQuickPickContextKey } from '../../../browser/quickaccess.js';
+import { IHoverService } from '../../hover/browser/hover.js';
+let QuickInputService = class QuickInputService extends QuickInputService$1 {
+    constructor(configurationService, instantiationService, keybindingService, contextKeyService, themeService, layoutService, hoverService) {
+        super(instantiationService, contextKeyService, themeService, layoutService);
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.hoverService = hoverService;
+        this.hoverDelegate = ( new QuickInputHoverDelegate(this.configurationService, this.hoverService));
+        this.inQuickInputContext = InQuickPickContextKey.bindTo(this.contextKeyService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onShow(() => this.inQuickInputContext.set(true)));
+        this._register(this.onHide(() => this.inQuickInputContext.set(false)));
+    }
+    createController() {
+        return super.createController(this.layoutService, {
+            ignoreFocusOut: () => !this.configurationService.getValue('workbench.quickOpen.closeOnFocusLost'),
+            backKeybindingLabel: () => this.keybindingService.lookupKeybinding('workbench.action.quickInputBack')?.getLabel() || undefined,
+            hoverDelegate: this.hoverDelegate
+        });
+    }
+};
+QuickInputService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, ILayoutService)),
+    ( __param(6, IHoverService))
+], QuickInputService));
+class QuickInputHoverDelegate {
+    get delay() {
+        if (Date.now() - this.lastHoverHideTime < 200) {
+            return 0;
+        }
+        return this.configurationService.getValue('workbench.hover.delay');
+    }
+    constructor(configurationService, hoverService) {
+        this.configurationService = configurationService;
+        this.hoverService = hoverService;
+        this.lastHoverHideTime = 0;
+        this.placement = 'element';
+    }
+    showHover(options, focus) {
+        return this.hoverService.showHover({
+            ...options,
+            showHoverHint: true,
+            hideOnKeyDown: false,
+            skipFadeInAnimation: true,
+        }, focus);
+    }
+    onDidHideHover() {
+        this.lastHoverHideTime = Date.now();
+    }
+}
+export { QuickInputService };

package/dist/vscode/vs/workbench/services/search/common/search.js

@@ -1,94 +1,13 @@
-import { mapArrayOrNot } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
 import * as extpath from 'monaco-editor/esm/vs/base/common/extpath.js';
-import { getNLines } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-const SEARCH_ELIDED_PREFIX = '⟪ ';
-const SEARCH_ELIDED_SUFFIX = ' characters skipped ⟫';
-const SEARCH_ELIDED_MIN_LEN = (SEARCH_ELIDED_PREFIX.length + SEARCH_ELIDED_SUFFIX.length + 5) * 2;
+const SEARCH_EXCLUDE_CONFIG = 'search.exclude';
 const ISearchService = ( createDecorator('searchService'));
 function resultIsMatch(result) {
     return !!result.preview;
 }
-function isFileMatch(p) {
-    return !!p.resource;
-}
-function isProgressMessage(p) {
-    return !!p.message;
-}
-class FileMatch {
-    constructor(resource) {
-        this.resource = resource;
-        this.results = [];
-    }
-}
-class TextSearchMatch {
-    constructor(text, range, previewOptions, webviewIndex) {
-        this.ranges = range;
-        this.webviewIndex = webviewIndex;
-        const ranges = Array.isArray(range) ? range : [range];
-        if (previewOptions && previewOptions.matchLines === 1 && isSingleLineRangeList(ranges)) {
-            text = getNLines(text, previewOptions.matchLines);
-            let result = '';
-            let shift = 0;
-            let lastEnd = 0;
-            const leadingChars = Math.floor(previewOptions.charsPerLine / 5);
-            const matches = [];
-            for (const range of ranges) {
-                const previewStart = Math.max(range.startColumn - leadingChars, 0);
-                const previewEnd = range.startColumn + previewOptions.charsPerLine;
-                if (previewStart > lastEnd + leadingChars + SEARCH_ELIDED_MIN_LEN) {
-                    const elision = SEARCH_ELIDED_PREFIX + (previewStart - lastEnd) + SEARCH_ELIDED_SUFFIX;
-                    result += elision + text.slice(previewStart, previewEnd);
-                    shift += previewStart - (lastEnd + elision.length);
-                }
-                else {
-                    result += text.slice(lastEnd, previewEnd);
-                }
-                matches.push(( new OneLineRange(0, range.startColumn - shift, range.endColumn - shift)));
-                lastEnd = previewEnd;
-            }
-            this.preview = { text: result, matches: Array.isArray(this.ranges) ? matches : matches[0] };
-        }
-        else {
-            const firstMatchLine = Array.isArray(range) ? range[0].startLineNumber : range.startLineNumber;
-            this.preview = {
-                text,
-                matches: mapArrayOrNot(range, r => ( new SearchRange(
-                    r.startLineNumber - firstMatchLine,
-                    r.startColumn,
-                    r.endLineNumber - firstMatchLine,
-                    r.endColumn
-                )))
-            };
-        }
-    }
-}
-function isSingleLineRangeList(ranges) {
-    const line = ranges[0].startLineNumber;
-    for (const r of ranges) {
-        if (r.startLineNumber !== line || r.endLineNumber !== line) {
-            return false;
-        }
-    }
-    return true;
-}
-class SearchRange {
-    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {
-        this.startLineNumber = startLineNumber;
-        this.startColumn = startColumn;
-        this.endLineNumber = endLineNumber;
-        this.endColumn = endColumn;
-    }
-}
-class OneLineRange extends SearchRange {
-    constructor(lineNumber, startColumn, endColumn) {
-        super(lineNumber, startColumn, lineNumber, endColumn);
-    }
-}
 function getExcludes(configuration, includeSearchExcludes = true) {
     const fileExcludes = configuration && configuration.files && configuration.files.exclude;
     const searchExcludes = includeSearchExcludes && configuration && configuration.search && configuration.search.exclude;
@@ -127,33 +46,4 @@ function pathIncludedInQuery(queryProps, fsPath) {
     }
     return true;
 }
-var SearchErrorCode;
-( (function(SearchErrorCode) {
-    SearchErrorCode[SearchErrorCode["unknownEncoding"] = 1] = "unknownEncoding";
-    SearchErrorCode[SearchErrorCode["regexParseError"] = 2] = "regexParseError";
-    SearchErrorCode[SearchErrorCode["globParseError"] = 3] = "globParseError";
-    SearchErrorCode[SearchErrorCode["invalidLiteral"] = 4] = "invalidLiteral";
-    SearchErrorCode[SearchErrorCode["rgProcessError"] = 5] = "rgProcessError";
-    SearchErrorCode[SearchErrorCode["other"] = 6] = "other";
-    SearchErrorCode[SearchErrorCode["canceled"] = 7] = "canceled";
-})(SearchErrorCode || (SearchErrorCode = {})));
-class SearchError extends Error {
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-    }
-}
-function deserializeSearchError(error) {
-    const errorMsg = error.message;
-    if (isCancellationError(error)) {
-        return ( new SearchError(errorMsg, SearchErrorCode.canceled));
-    }
-    try {
-        const details = JSON.parse(errorMsg);
-        return ( new SearchError(details.message, details.code));
-    }
-    catch (e) {
-        return ( new SearchError(errorMsg, SearchErrorCode.other));
-    }
-}
-export { FileMatch, ISearchService, OneLineRange, SearchError, SearchErrorCode, SearchRange, TextSearchMatch, deserializeSearchError, getExcludes, isFileMatch, isProgressMessage, pathIncludedInQuery, resultIsMatch };
+export { ISearchService, SEARCH_EXCLUDE_CONFIG, getExcludes, pathIncludedInQuery, resultIsMatch };

package/dist/vscode/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.js

@@ -1,3 +1,56 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { timeout, createCancelablePromise, raceCancellablePromises } from 'monaco-editor/esm/vs/base/common/async.js';
 const ISemanticSimilarityService = ( createDecorator('ISemanticSimilarityService'));
-export { ISemanticSimilarityService };
+class SemanticSimilarityService {
+    constructor() {
+        this._providers = [];
+    }
+    isEnabled() {
+        return this._providers.length > 0;
+    }
+    registerSemanticSimilarityProvider(provider) {
+        this._providers.push(provider);
+        return {
+            dispose: () => {
+                const index = this._providers.indexOf(provider);
+                if (index >= 0) {
+                    this._providers.splice(index, 1);
+                }
+            }
+        };
+    }
+    async getSimilarityScore(string1, comparisons, token) {
+        if (this._providers.length === 0) {
+            throw new Error('No semantic similarity providers registered');
+        }
+        const cancellablePromises = [];
+        const timer = timeout(SemanticSimilarityService.DEFAULT_TIMEOUT);
+        const disposable = token.onCancellationRequested(() => {
+            disposable.dispose();
+            timer.cancel();
+        });
+        for (const provider of this._providers) {
+            cancellablePromises.push(createCancelablePromise(async (t) => {
+                try {
+                    return await provider.provideSimilarityScore(string1, comparisons, t);
+                }
+                catch (e) {
+                }
+                await timer;
+                throw new Error('Semantic similarity provider timed out');
+            }));
+        }
+        cancellablePromises.push(createCancelablePromise(async (t) => {
+            const disposable = t.onCancellationRequested(() => {
+                timer.cancel();
+                disposable.dispose();
+            });
+            await timer;
+            throw new Error('Semantic similarity provider timed out');
+        }));
+        const result = await raceCancellablePromises(cancellablePromises);
+        return result;
+    }
+}
+SemanticSimilarityService.DEFAULT_TIMEOUT = 1000 * 10;
+export { ISemanticSimilarityService, SemanticSimilarityService };

package/dist/vscode/vs/workbench/services/statusbar/browser/statusbar.js

@@ -0,0 +1,15 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IStatusbarService = ( createDecorator('statusbarService'));
+function isStatusbarEntryLocation(thing) {
+    const candidate = thing;
+    return typeof candidate?.id === 'string' && typeof candidate.alignment === 'number';
+}
+function isStatusbarEntryPriority(thing) {
+    const candidate = thing;
+    return (typeof candidate?.primary === 'number' || isStatusbarEntryLocation(candidate?.primary)) && typeof candidate?.secondary === 'number';
+}
+const ShowTooltipCommand = {
+    id: 'statusBar.entry.showTooltip',
+    title: ''
+};
+export { IStatusbarService, ShowTooltipCommand, isStatusbarEntryLocation, isStatusbarEntryPriority };

package/dist/vscode/vs/workbench/services/textMate/browser/worker/textMate.worker.js

@@ -0,0 +1,90 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { TMGrammarFactory } from '../../common/TMGrammarFactory.js';
+import { TextMateWorkerModel } from './textMateWorkerModel.js';
+class TextMateTokenizationWorker {
+    constructor(ctx, createData) {
+        this.createData = createData;
+        this._models = Object.create(null);
+        this._grammarCache = [];
+        this._host = ctx.host;
+        const grammarDefinitions = ( createData.grammarDefinitions.map((def) => {
+            return {
+                location: URI.revive(def.location),
+                language: def.language,
+                scopeName: def.scopeName,
+                embeddedLanguages: def.embeddedLanguages,
+                tokenTypes: def.tokenTypes,
+                injectTo: def.injectTo,
+                balancedBracketSelectors: def.balancedBracketSelectors,
+                unbalancedBracketSelectors: def.unbalancedBracketSelectors,
+            };
+        }));
+        this._grammarFactory = this._loadTMGrammarFactory(grammarDefinitions);
+    }
+    async _loadTMGrammarFactory(grammarDefinitions) {
+        const vscodeTextmate = await import('vscode-textmate').then(module => module.default ?? module);
+        const vscodeOniguruma = await import('vscode-oniguruma').then(module => module.default ?? module);
+        const response = await fetch(this.createData.onigurumaWASMUri);
+        const bytes = await response.arrayBuffer();
+        await vscodeOniguruma.loadWASM(bytes);
+        const onigLib = Promise.resolve({
+            createOnigScanner: (sources) => vscodeOniguruma.createOnigScanner(sources),
+            createOnigString: (str) => vscodeOniguruma.createOnigString(str)
+        });
+        return ( new TMGrammarFactory({
+            logTrace: (msg) => { },
+            logError: (msg, err) => console.error(msg, err),
+            readFile: (resource) => this._host.readFile(resource)
+        }, grammarDefinitions, vscodeTextmate, onigLib));
+    }
+    acceptNewModel(data) {
+        const uri = URI.revive(data.uri);
+        const key = ( uri.toString());
+        this._models[key] = ( new TextMateWorkerModel(
+            uri,
+            data.lines,
+            data.EOL,
+            data.versionId,
+            this,
+            data.languageId,
+            data.encodedLanguageId,
+            data.maxTokenizationLineLength
+        ));
+    }
+    acceptModelChanged(strURL, e) {
+        this._models[strURL].onEvents(e);
+    }
+    retokenize(strURL, startLineNumber, endLineNumberExclusive) {
+        this._models[strURL].retokenize(startLineNumber, endLineNumberExclusive);
+    }
+    acceptModelLanguageChanged(strURL, newLanguageId, newEncodedLanguageId) {
+        this._models[strURL].onLanguageId(newLanguageId, newEncodedLanguageId);
+    }
+    acceptRemovedModel(strURL) {
+        if (this._models[strURL]) {
+            this._models[strURL].dispose();
+            delete this._models[strURL];
+        }
+    }
+    async acceptTheme(theme, colorMap) {
+        const grammarFactory = await this._grammarFactory;
+        grammarFactory?.setTheme(theme, colorMap);
+    }
+    acceptMaxTokenizationLineLength(strURL, value) {
+        this._models[strURL].acceptMaxTokenizationLineLength(value);
+    }
+    async getOrCreateGrammar(languageId, encodedLanguageId) {
+        const grammarFactory = await this._grammarFactory;
+        if (!grammarFactory) {
+            return Promise.resolve(null);
+        }
+        if (!this._grammarCache[encodedLanguageId]) {
+            this._grammarCache[encodedLanguageId] = grammarFactory.createGrammar(languageId, encodedLanguageId);
+        }
+        return this._grammarCache[encodedLanguageId];
+    }
+    setTokensAndStates(resource, versionId, tokens, stateDeltas) {
+        this._host.setTokensAndStates(resource, versionId, tokens, stateDeltas);
+    }
+}
+export { TextMateTokenizationWorker };

package/dist/vscode/vs/workbench/services/textMate/browser/worker/textMateWorkerModel.js

@@ -0,0 +1,133 @@
+import { MirrorTextModel } from 'monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js';
+import { TokenizerWithStateStore } from 'monaco-editor/esm/vs/editor/common/model/textModelTokens.js';
+import { diffStateStacksRefEq } from 'vscode-textmate';
+import { ContiguousMultilineTokensBuilder } from 'monaco-editor/esm/vs/editor/common/tokens/contiguousMultilineTokensBuilder.js';
+import { LineTokens } from 'monaco-editor/esm/vs/editor/common/tokens/lineTokens.js';
+import { TextMateTokenizationSupport } from '../tokenizationSupport/textMateTokenizationSupport.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { observableValue } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { TokenizationSupportWithLineLimit } from '../tokenizationSupport/tokenizationSupportWithLineLimit.js';
+import { LineRange } from 'monaco-editor/esm/vs/editor/common/core/lineRange.js';
+class TextMateWorkerModel extends MirrorTextModel {
+    constructor(uri, lines, eol, versionId, _worker, _languageId, _encodedLanguageId, maxTokenizationLineLength) {
+        super(uri, lines, eol, versionId);
+        this._worker = _worker;
+        this._languageId = _languageId;
+        this._encodedLanguageId = _encodedLanguageId;
+        this._tokenizationStateStore = null;
+        this._isDisposed = false;
+        this._maxTokenizationLineLength = observableValue('_maxTokenizationLineLength', -1);
+        this.tokenizeDebouncer = ( new RunOnceScheduler(() => this._tokenize(), 10));
+        this._maxTokenizationLineLength.set(maxTokenizationLineLength, undefined);
+        this._resetTokenization();
+    }
+    dispose() {
+        this._isDisposed = true;
+        super.dispose();
+    }
+    onLanguageId(languageId, encodedLanguageId) {
+        this._languageId = languageId;
+        this._encodedLanguageId = encodedLanguageId;
+        this._resetTokenization();
+    }
+    onEvents(e) {
+        super.onEvents(e);
+        if (this._tokenizationStateStore) {
+            this._tokenizationStateStore.store.acceptChanges(e.changes);
+        }
+        this.tokenizeDebouncer.schedule();
+    }
+    acceptMaxTokenizationLineLength(maxTokenizationLineLength) {
+        this._maxTokenizationLineLength.set(maxTokenizationLineLength, undefined);
+    }
+    retokenize(startLineNumber, endLineNumberExclusive) {
+        if (this._tokenizationStateStore) {
+            this._tokenizationStateStore.store.invalidateEndStateRange(( new LineRange(startLineNumber, endLineNumberExclusive)));
+            this.tokenizeDebouncer.schedule();
+        }
+    }
+    _resetTokenization() {
+        this._tokenizationStateStore = null;
+        const languageId = this._languageId;
+        const encodedLanguageId = this._encodedLanguageId;
+        this._worker.getOrCreateGrammar(languageId, encodedLanguageId).then((r) => {
+            if (this._isDisposed ||
+                languageId !== this._languageId ||
+                encodedLanguageId !== this._encodedLanguageId ||
+                !r) {
+                return;
+            }
+            if (r.grammar) {
+                const tokenizationSupport = ( new TokenizationSupportWithLineLimit(this._encodedLanguageId, ( new TextMateTokenizationSupport(r.grammar, r.initialState, false)), this._maxTokenizationLineLength));
+                this._tokenizationStateStore = ( new TokenizerWithStateStore(this._lines.length, tokenizationSupport));
+            }
+            else {
+                this._tokenizationStateStore = null;
+            }
+            this._tokenize();
+        });
+    }
+    _tokenize() {
+        if (this._isDisposed || !this._tokenizationStateStore) {
+            return;
+        }
+        const startTime = ( new Date()).getTime();
+        while (true) {
+            let tokenizedLines = 0;
+            const tokenBuilder = ( new ContiguousMultilineTokensBuilder());
+            const stateDeltaBuilder = ( new StateDeltaBuilder());
+            while (true) {
+                const lineNumberToTokenize = this._tokenizationStateStore.store.getFirstInvalidEndStateLineNumber();
+                if (lineNumberToTokenize === null || tokenizedLines > 200) {
+                    break;
+                }
+                tokenizedLines++;
+                const text = this._lines[lineNumberToTokenize - 1];
+                const lineStartState = this._tokenizationStateStore.getStartState(lineNumberToTokenize);
+                const r = this._tokenizationStateStore.tokenizationSupport.tokenizeEncoded(text, true, lineStartState);
+                if (this._tokenizationStateStore.store.setEndState(lineNumberToTokenize, r.endState)) {
+                    const delta = diffStateStacksRefEq(lineStartState, r.endState);
+                    stateDeltaBuilder.setState(lineNumberToTokenize, delta);
+                }
+                else {
+                    stateDeltaBuilder.setState(lineNumberToTokenize, null);
+                }
+                LineTokens.convertToEndOffset(r.tokens, text.length);
+                tokenBuilder.add(lineNumberToTokenize, r.tokens);
+                const deltaMs = ( new Date()).getTime() - startTime;
+                if (deltaMs > 20) {
+                    break;
+                }
+            }
+            if (tokenizedLines === 0) {
+                break;
+            }
+            const stateDeltas = stateDeltaBuilder.getStateDeltas();
+            this._worker.setTokensAndStates(this._uri, this._versionId, tokenBuilder.serialize(), stateDeltas);
+            const deltaMs = ( new Date()).getTime() - startTime;
+            if (deltaMs > 20) {
+                setTimeout(() => this._tokenize(), 3);
+                return;
+            }
+        }
+    }
+}
+class StateDeltaBuilder {
+    constructor() {
+        this._lastStartLineNumber = -1;
+        this._stateDeltas = [];
+    }
+    setState(lineNumber, stackDiff) {
+        if (lineNumber === this._lastStartLineNumber + 1) {
+            this._stateDeltas[this._stateDeltas.length - 1].stateDeltas.push(stackDiff);
+        }
+        else {
+            this._stateDeltas.push({ startLineNumber: lineNumber, stateDeltas: [stackDiff] });
+        }
+        this._lastStartLineNumber = lineNumber;
+    }
+    getStateDeltas() {
+        return this._stateDeltas;
+    }
+}
+export { TextMateWorkerModel };