@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/services/textMate/browser/workerHost/textMateWorkerHost.js

@@ -0,0 +1,198 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { BugIndicatingError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { FileAccess, nodeModulesPath, nodeModulesAsarPath } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createWebWorker } from 'monaco-editor/esm/vs/editor/browser/services/webWorker.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IExtensionResourceLoaderService } from '../../../../../platform/extensionResourceLoader/common/extensionResourceLoader.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { TextMateWorkerTokenizerController } from './textMateWorkerTokenizerController.js';
+import { INITIAL } from 'vscode-textmate';
+let TextMateWorkerHost = class TextMateWorkerHost {
+    constructor(_extensionResourceLoaderService, _modelService, _languageConfigurationService, _configurationService, _languageService, _environmentService, _notificationService, _telemetryService) {
+        this._extensionResourceLoaderService = _extensionResourceLoaderService;
+        this._modelService = _modelService;
+        this._languageConfigurationService = _languageConfigurationService;
+        this._configurationService = _configurationService;
+        this._languageService = _languageService;
+        this._environmentService = _environmentService;
+        this._notificationService = _notificationService;
+        this._telemetryService = _telemetryService;
+        this._workerProxyPromise = null;
+        this._worker = null;
+        this._workerProxy = null;
+        this._workerTokenizerControllers = ( new Map());
+        this._currentTheme = null;
+        this._currentTokenColorMap = null;
+        this._grammarDefinitions = [];
+    }
+    setGrammarDefinitions(grammarDefinitions) {
+        this._grammarDefinitions = grammarDefinitions;
+        this._killWorker();
+    }
+    dispose() {
+        this._killWorker();
+    }
+    acceptTheme(theme, colorMap) {
+        this._currentTheme = theme;
+        this._currentTokenColorMap = colorMap;
+        if (this._currentTheme && this._currentTokenColorMap && this._workerProxy) {
+            this._workerProxy.acceptTheme(this._currentTheme, this._currentTokenColorMap);
+        }
+    }
+    getWorkerProxy() {
+        if (!this._workerProxyPromise) {
+            this._workerProxyPromise = this.createWorkerProxy();
+        }
+        return this._workerProxyPromise;
+    }
+    async createWorkerProxy() {
+        const textmateModuleLocation = `${nodeModulesPath}/vscode-textmate`;
+        const textmateModuleLocationAsar = `${nodeModulesAsarPath}/vscode-textmate`;
+        const onigurumaModuleLocation = `${nodeModulesPath}/vscode-oniguruma`;
+        const onigurumaModuleLocationAsar = `${nodeModulesAsarPath}/vscode-oniguruma`;
+        const useAsar = this._environmentService.isBuilt && !isWeb;
+        const textmateLocation = useAsar ? textmateModuleLocationAsar : textmateModuleLocation;
+        const onigurumaLocation = useAsar ? onigurumaModuleLocationAsar : onigurumaModuleLocation;
+        const textmateMain = `${textmateLocation}/release/main.js`;
+        const onigurumaMain = `${onigurumaLocation}/release/main.js`;
+        const onigurumaWASM = `${onigurumaLocation}/release/onig.wasm`;
+        const uri = ( ( FileAccess.asBrowserUri(textmateMain)).toString(true));
+        const createData = {
+            grammarDefinitions: this._grammarDefinitions,
+            textmateMainUri: uri,
+            onigurumaMainUri: ( ( FileAccess.asBrowserUri(onigurumaMain)).toString(true)),
+            onigurumaWASMUri: ( ( FileAccess.asBrowserUri(onigurumaWASM)).toString(true)),
+        };
+        const worker = createWebWorker(this._modelService, this._languageConfigurationService, {
+            createData,
+            label: 'textMateWorker',
+            moduleId: 'vs/workbench/services/textMate/browser/worker/textMate.worker',
+            host: this,
+        });
+        this._worker = worker;
+        const proxy = await ( worker.getProxy());
+        if (this._worker !== worker) {
+            return null;
+        }
+        this._workerProxy = proxy;
+        if (this._currentTheme && this._currentTokenColorMap) {
+            this._workerProxy.acceptTheme(this._currentTheme, this._currentTokenColorMap);
+        }
+        return proxy;
+    }
+    _killWorker() {
+        for (const controller of ( this._workerTokenizerControllers.values())) {
+            controller.dispose();
+        }
+        this._workerTokenizerControllers.clear();
+        if (this._worker) {
+            this._worker.dispose();
+            this._worker = null;
+        }
+        this._workerProxy = null;
+        this._workerProxyPromise = null;
+    }
+    createBackgroundTokenizer(textModel, tokenStore, maxTokenizationLineLength) {
+        if (this._workerTokenizerControllers.has(( textModel.uri.toString()))) {
+            throw new BugIndicatingError();
+        }
+        const shouldTokenizeAsync = this._configurationService.getValue('editor.experimental.asyncTokenization');
+        if (shouldTokenizeAsync !== true) {
+            return undefined;
+        }
+        if (textModel.isTooLargeForSyncing()) {
+            return undefined;
+        }
+        const store = ( new DisposableStore());
+        this.getWorkerProxy().then((workerProxy) => {
+            if (store.isDisposed || !workerProxy) {
+                return;
+            }
+            store.add(keepAliveWhenAttached(textModel, () => {
+                const controller = ( new TextMateWorkerTokenizerController(
+                    textModel,
+                    workerProxy,
+                    this._languageService.languageIdCodec,
+                    tokenStore,
+                    INITIAL,
+                    this._configurationService,
+                    maxTokenizationLineLength
+                ));
+                this._workerTokenizerControllers.set(( textModel.uri.toString()), controller);
+                return toDisposable(() => {
+                    this._workerTokenizerControllers.delete(( textModel.uri.toString()));
+                    controller.dispose();
+                });
+            }));
+        });
+        return {
+            dispose() {
+                store.dispose();
+            },
+            requestTokens: (startLineNumber, endLineNumberExclusive) => {
+                this.getWorkerProxy().then((workerProxy) => {
+                    workerProxy?.retokenize(( textModel.uri.toString()), startLineNumber, endLineNumberExclusive);
+                });
+            },
+            reportMismatchingTokens: (lineNumber) => {
+                if (TextMateWorkerHost._reportedMismatchingTokens) {
+                    return;
+                }
+                TextMateWorkerHost._reportedMismatchingTokens = true;
+                this._notificationService.error({
+                    message: 'Async Tokenization Token Mismatch in line ' + lineNumber,
+                    name: 'Async Tokenization Token Mismatch',
+                });
+                this._telemetryService.publicLog2('asyncTokenizationMismatchingTokens', {});
+            },
+        };
+    }
+    async readFile(_resource) {
+        const resource = URI.revive(_resource);
+        return this._extensionResourceLoaderService.readExtensionResource(resource);
+    }
+    async setTokensAndStates(_resource, versionId, tokens, lineEndStateDeltas) {
+        const resource = URI.revive(_resource);
+        const controller = this._workerTokenizerControllers.get(( resource.toString()));
+        if (controller) {
+            controller.setTokensAndStates(versionId, tokens, lineEndStateDeltas);
+        }
+    }
+};
+TextMateWorkerHost._reportedMismatchingTokens = false;
+TextMateWorkerHost = ( __decorate([
+    ( __param(0, IExtensionResourceLoaderService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageConfigurationService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ILanguageService)),
+    ( __param(5, IEnvironmentService)),
+    ( __param(6, INotificationService)),
+    ( __param(7, ITelemetryService))
+], TextMateWorkerHost));
+function keepAliveWhenAttached(textModel, factory) {
+    const disposableStore = ( new DisposableStore());
+    const subStore = disposableStore.add(( new DisposableStore()));
+    function checkAttached() {
+        if (textModel.isAttachedToEditor()) {
+            subStore.add(factory());
+        }
+        else {
+            subStore.clear();
+        }
+    }
+    checkAttached();
+    disposableStore.add(textModel.onDidChangeAttached(() => {
+        checkAttached();
+    }));
+    return disposableStore;
+}
+export { TextMateWorkerHost };

package/dist/vscode/vs/workbench/services/textMate/browser/workerHost/textMateWorkerTokenizerController.js

@@ -0,0 +1,151 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { keepAlive, autorun, observableFromEvent } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { countEOL } from 'monaco-editor/esm/vs/editor/common/core/eolCounter.js';
+import { LineRange } from 'monaco-editor/esm/vs/editor/common/core/lineRange.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { TokenizationStateStore } from 'monaco-editor/esm/vs/editor/common/model/textModelTokens.js';
+import { ContiguousMultilineTokensBuilder } from 'monaco-editor/esm/vs/editor/common/tokens/contiguousMultilineTokensBuilder.js';
+import { MonotonousIndexTransformer, ArrayEdit, SingleArrayEdit } from '../arrayOperation.js';
+import { applyStateStackDiff } from 'vscode-textmate';
+class TextMateWorkerTokenizerController extends Disposable {
+    constructor(_model, _worker, _languageIdCodec, _backgroundTokenizationStore, _initialState, _configurationService, _maxTokenizationLineLength) {
+        super();
+        this._model = _model;
+        this._worker = _worker;
+        this._languageIdCodec = _languageIdCodec;
+        this._backgroundTokenizationStore = _backgroundTokenizationStore;
+        this._initialState = _initialState;
+        this._configurationService = _configurationService;
+        this._maxTokenizationLineLength = _maxTokenizationLineLength;
+        this._pendingChanges = [];
+        this._states = ( new TokenizationStateStore());
+        this._loggingEnabled = observableConfigValue('editor.experimental.asyncTokenizationLogging', false, this._configurationService);
+        this._register(keepAlive(this._loggingEnabled));
+        this._register(this._model.onDidChangeContent((e) => {
+            if (this.shouldLog) {
+                console.log('model change', {
+                    fileName: this._model.uri.fsPath.split('\\').pop(),
+                    changes: changesToString(e.changes),
+                });
+            }
+            this._worker.acceptModelChanged(( this._model.uri.toString()), e);
+            this._pendingChanges.push(e);
+        }));
+        this._register(this._model.onDidChangeLanguage((e) => {
+            const languageId = this._model.getLanguageId();
+            const encodedLanguageId = this._languageIdCodec.encodeLanguageId(languageId);
+            this._worker.acceptModelLanguageChanged(( this._model.uri.toString()), languageId, encodedLanguageId);
+        }));
+        const languageId = this._model.getLanguageId();
+        const encodedLanguageId = this._languageIdCodec.encodeLanguageId(languageId);
+        this._worker.acceptNewModel({
+            uri: this._model.uri,
+            versionId: this._model.getVersionId(),
+            lines: this._model.getLinesContent(),
+            EOL: this._model.getEOL(),
+            languageId,
+            encodedLanguageId,
+            maxTokenizationLineLength: this._maxTokenizationLineLength.get(),
+        });
+        this._register(autorun('update maxTokenizationLineLength', reader => {
+            const maxTokenizationLineLength = this._maxTokenizationLineLength.read(reader);
+            this._worker.acceptMaxTokenizationLineLength(( this._model.uri.toString()), maxTokenizationLineLength);
+        }));
+    }
+    get shouldLog() {
+        return this._loggingEnabled.get();
+    }
+    dispose() {
+        super.dispose();
+        this._worker.acceptRemovedModel(( this._model.uri.toString()));
+    }
+    setTokensAndStates(versionId, rawTokens, stateDeltas) {
+        let tokens = ContiguousMultilineTokensBuilder.deserialize(( new Uint8Array(rawTokens)));
+        if (this.shouldLog) {
+            console.log('received background tokenization result', {
+                fileName: this._model.uri.fsPath.split('\\').pop(),
+                updatedTokenLines: ( tokens.map((t) => t.getLineRange())).join(' & '),
+                updatedStateLines: ( stateDeltas.map((s) => ( ( new LineRange(s.startLineNumber, s.startLineNumber + s.stateDeltas.length)).toString()))).join(' & '),
+            });
+        }
+        if (this.shouldLog) {
+            const changes = ( ( this._pendingChanges.filter(c => c.versionId <= versionId).map(c => c.changes)).map(c => changesToString(c))).join(' then ');
+            console.log('Applying changes to local states', changes);
+        }
+        while (this._pendingChanges.length > 0 &&
+            this._pendingChanges[0].versionId <= versionId) {
+            const change = this._pendingChanges.shift();
+            this._states.acceptChanges(change.changes);
+        }
+        if (this._pendingChanges.length > 0) {
+            if (this.shouldLog) {
+                const changes = ( ( this._pendingChanges.map(c => c.changes)).map(c => changesToString(c))).join(' then ');
+                console.log('Considering non-processed changes', changes);
+            }
+            const curToFutureTransformerTokens = MonotonousIndexTransformer.fromMany(( this._pendingChanges.map((c) => ( new ArrayEdit(( c.changes.map((c) => ( new SingleArrayEdit(
+                c.range.startLineNumber - 1,
+                (c.range.endLineNumber - c.range.startLineNumber) + 1,
+                countEOL(c.text)[0] + 1
+            )))))))));
+            const b = ( new ContiguousMultilineTokensBuilder());
+            for (const t of tokens) {
+                for (let i = t.startLineNumber; i <= t.endLineNumber; i++) {
+                    const result = curToFutureTransformerTokens.transform(i - 1);
+                    if (result !== undefined) {
+                        b.add(i, t.getLineTokens(i));
+                    }
+                }
+            }
+            tokens = b.finalize();
+            for (const change of this._pendingChanges) {
+                for (const innerChanges of change.changes) {
+                    for (let j = 0; j < tokens.length; j++) {
+                        tokens[j].applyEdit(innerChanges.range, innerChanges.text);
+                    }
+                }
+            }
+        }
+        this._backgroundTokenizationStore.setTokens(tokens);
+        const curToFutureTransformerStates = MonotonousIndexTransformer.fromMany(( this._pendingChanges.map((c) => lineArrayEditFromModelContentChange(c.changes))));
+        for (const d of stateDeltas) {
+            let prevState = d.startLineNumber <= 1 ? this._initialState : this._states.getEndState(d.startLineNumber - 1);
+            for (let i = 0; i < d.stateDeltas.length; i++) {
+                const delta = d.stateDeltas[i];
+                let state;
+                if (delta) {
+                    state = applyStateStackDiff(prevState, delta);
+                    this._states.setEndState(d.startLineNumber + i, state);
+                }
+                else {
+                    state = this._states.getEndState(d.startLineNumber + i);
+                }
+                const offset = curToFutureTransformerStates.transform(d.startLineNumber + i - 1);
+                if (offset !== undefined) {
+                    this._backgroundTokenizationStore.setEndState(offset + 1, state);
+                }
+                if (d.startLineNumber + i >= this._model.getLineCount() - 1) {
+                    this._backgroundTokenizationStore.backgroundTokenizationFinished();
+                }
+                prevState = state;
+            }
+        }
+    }
+}
+function lineArrayEditFromModelContentChange(c) {
+    return ( new ArrayEdit(( c.map((c) => ( new SingleArrayEdit(
+        c.range.startLineNumber - 1,
+        c.range.endLineNumber - c.range.startLineNumber,
+        countEOL(c.text)[0]
+    ))))));
+}
+function changesToString(changes) {
+    return ( changes.map(c => ( Range.lift(c.range).toString()) + ' => ' + c.text)).join(' & ');
+}
+function observableConfigValue(key, defaultValue, configurationService) {
+    return observableFromEvent((handleChange) => configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(key)) {
+            handleChange(e);
+        }
+    }), () => configurationService.getValue(key) ?? defaultValue);
+}
+export { TextMateWorkerTokenizerController };

package/dist/vscode/vs/workbench/services/textMate/common/TMGrammarFactory.js

@@ -0,0 +1,117 @@
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { TMScopeRegistry } from './TMScopeRegistry.js';
+const missingTMGrammarErrorMessage = 'No TM Grammar registered for this language.';
+class TMGrammarFactory extends Disposable {
+    constructor(host, grammarDefinitions, vscodeTextmate, onigLib) {
+        super();
+        this._host = host;
+        this._initialState = vscodeTextmate.INITIAL;
+        this._scopeRegistry = ( new TMScopeRegistry());
+        this._injections = {};
+        this._injectedEmbeddedLanguages = {};
+        this._languageToScope = ( new Map());
+        this._grammarRegistry = this._register(new vscodeTextmate.Registry({
+            onigLib: onigLib,
+            loadGrammar: async (scopeName) => {
+                const grammarDefinition = this._scopeRegistry.getGrammarDefinition(scopeName);
+                if (!grammarDefinition) {
+                    this._host.logTrace(`No grammar found for scope ${scopeName}`);
+                    return null;
+                }
+                const location = grammarDefinition.location;
+                try {
+                    const content = await this._host.readFile(location);
+                    return vscodeTextmate.parseRawGrammar(content, location.path);
+                }
+                catch (e) {
+                    this._host.logError(`Unable to load and parse grammar for scope ${scopeName} from ${location}`, e);
+                    return null;
+                }
+            },
+            getInjections: (scopeName) => {
+                const scopeParts = scopeName.split('.');
+                let injections = [];
+                for (let i = 1; i <= scopeParts.length; i++) {
+                    const subScopeName = scopeParts.slice(0, i).join('.');
+                    injections = [...injections, ...(this._injections[subScopeName] || [])];
+                }
+                return injections;
+            }
+        }));
+        for (const validGrammar of grammarDefinitions) {
+            this._scopeRegistry.register(validGrammar);
+            if (validGrammar.injectTo) {
+                for (const injectScope of validGrammar.injectTo) {
+                    let injections = this._injections[injectScope];
+                    if (!injections) {
+                        this._injections[injectScope] = injections = [];
+                    }
+                    injections.push(validGrammar.scopeName);
+                }
+                if (validGrammar.embeddedLanguages) {
+                    for (const injectScope of validGrammar.injectTo) {
+                        let injectedEmbeddedLanguages = this._injectedEmbeddedLanguages[injectScope];
+                        if (!injectedEmbeddedLanguages) {
+                            this._injectedEmbeddedLanguages[injectScope] = injectedEmbeddedLanguages = [];
+                        }
+                        injectedEmbeddedLanguages.push(validGrammar.embeddedLanguages);
+                    }
+                }
+            }
+            if (validGrammar.language) {
+                this._languageToScope.set(validGrammar.language, validGrammar.scopeName);
+            }
+        }
+    }
+    has(languageId) {
+        return this._languageToScope.has(languageId);
+    }
+    setTheme(theme, colorMap) {
+        this._grammarRegistry.setTheme(theme, colorMap);
+    }
+    getColorMap() {
+        return this._grammarRegistry.getColorMap();
+    }
+    async createGrammar(languageId, encodedLanguageId) {
+        const scopeName = this._languageToScope.get(languageId);
+        if (typeof scopeName !== 'string') {
+            throw new Error(missingTMGrammarErrorMessage);
+        }
+        const grammarDefinition = this._scopeRegistry.getGrammarDefinition(scopeName);
+        if (!grammarDefinition) {
+            throw new Error(missingTMGrammarErrorMessage);
+        }
+        const embeddedLanguages = grammarDefinition.embeddedLanguages;
+        if (this._injectedEmbeddedLanguages[scopeName]) {
+            const injectedEmbeddedLanguages = this._injectedEmbeddedLanguages[scopeName];
+            for (const injected of injectedEmbeddedLanguages) {
+                for (const scope of ( Object.keys(injected))) {
+                    embeddedLanguages[scope] = injected[scope];
+                }
+            }
+        }
+        const containsEmbeddedLanguages = (( Object.keys(embeddedLanguages)).length > 0);
+        let grammar;
+        try {
+            grammar = await this._grammarRegistry.loadGrammarWithConfiguration(scopeName, encodedLanguageId, {
+                embeddedLanguages,
+                tokenTypes: grammarDefinition.tokenTypes,
+                balancedBracketSelectors: grammarDefinition.balancedBracketSelectors,
+                unbalancedBracketSelectors: grammarDefinition.unbalancedBracketSelectors,
+            });
+        }
+        catch (err) {
+            if (err.message && err.message.startsWith('No grammar provided for')) {
+                throw new Error(missingTMGrammarErrorMessage);
+            }
+            throw err;
+        }
+        return {
+            languageId: languageId,
+            grammar: grammar,
+            initialState: this._initialState,
+            containsEmbeddedLanguages: containsEmbeddedLanguages
+        };
+    }
+}
+export { TMGrammarFactory, missingTMGrammarErrorMessage };

package/dist/vscode/vs/workbench/services/textMate/common/TMGrammars.js

@@ -0,0 +1,93 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
+import { languagesExtPoint } from '../../language/common/languageService.js';
+const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'grammars',
+    deps: [languagesExtPoint],
+    jsonSchema: {
+        description: ( nls.localize(
+            'vscode.extension.contributes.grammars',
+            'Contributes textmate tokenizers.'
+        )),
+        type: 'array',
+        defaultSnippets: [{ body: [{ language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' }] }],
+        items: {
+            type: 'object',
+            defaultSnippets: [{ body: { language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' } }],
+            properties: {
+                language: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.language',
+                        'Language identifier for which this syntax is contributed to.'
+                    )),
+                    type: 'string'
+                },
+                scopeName: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.scopeName',
+                        'Textmate scope name used by the tmLanguage file.'
+                    )),
+                    type: 'string'
+                },
+                path: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.path',
+                        'Path of the tmLanguage file. The path is relative to the extension folder and typically starts with \'./syntaxes/\'.'
+                    )),
+                    type: 'string'
+                },
+                embeddedLanguages: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.embeddedLanguages',
+                        'A map of scope name to language id if this grammar contains embedded languages.'
+                    )),
+                    type: 'object'
+                },
+                tokenTypes: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.tokenTypes',
+                        'A map of scope name to token types.'
+                    )),
+                    type: 'object',
+                    additionalProperties: {
+                        enum: ['string', 'comment', 'other']
+                    }
+                },
+                injectTo: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.injectTo',
+                        'List of language scope names to which this grammar is injected to.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                balancedBracketScopes: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.balancedBracketScopes',
+                        'Defines which scope names contain balanced brackets.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    default: ['*'],
+                },
+                unbalancedBracketScopes: {
+                    description: ( nls.localize(
+                        'vscode.extension.contributes.grammars.unbalancedBracketScopes',
+                        'Defines which scope names do not contain balanced brackets.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    default: [],
+                },
+            },
+            required: ['scopeName', 'path']
+        }
+    }
+}));
+export { grammarsExtPoint };

package/dist/vscode/vs/workbench/services/textMate/common/TMScopeRegistry.js

@@ -0,0 +1,24 @@
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+class TMScopeRegistry {
+    constructor() {
+        this._scopeNameToLanguageRegistration = Object.create(null);
+    }
+    reset() {
+        this._scopeNameToLanguageRegistration = Object.create(null);
+    }
+    register(def) {
+        if (this._scopeNameToLanguageRegistration[def.scopeName]) {
+            const existingRegistration = this._scopeNameToLanguageRegistration[def.scopeName];
+            if (!resources.isEqual(existingRegistration.location, def.location)) {
+                console.warn(`Overwriting grammar scope name to file mapping for scope ${def.scopeName}.\n` +
+                    `Old grammar file: ${( ( existingRegistration.location.toString()))}.\n` +
+                    `New grammar file: ${( ( def.location.toString()))}`);
+            }
+        }
+        this._scopeNameToLanguageRegistration[def.scopeName] = def;
+    }
+    getGrammarDefinition(scopeName) {
+        return this._scopeNameToLanguageRegistration[scopeName] || null;
+    }
+}
+export { TMScopeRegistry };

package/dist/vscode/vs/workbench/services/textfile/browser/browserTextFileService.js

@@ -0,0 +1,55 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { AbstractTextFileService } from './textFileService.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.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 { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IDialogService, IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IElevatedFileService } from '../../files/common/elevatedFileService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { IPathService } from '../../path/common/pathService.js';
+import { IUntitledTextEditorService } from '../../untitled/common/untitledTextEditorService.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { IWorkingCopyFileService } from '../../workingCopy/common/workingCopyFileService.js';
+import { IDecorationsService } from '../../decorations/common/decorations.js';
+let BrowserTextFileService = class BrowserTextFileService extends AbstractTextFileService {
+    constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, elevatedFileService, logService, decorationsService) {
+        super(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles'));
+    }
+    onBeforeShutdown() {
+        if (( this.files.models.some(model => model.hasState(2 )))) {
+            return true;
+        }
+        return false;
+    }
+};
+BrowserTextFileService = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IUntitledTextEditorService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IModelService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IDialogService)),
+    ( __param(7, IFileDialogService)),
+    ( __param(8, ITextResourceConfigurationService)),
+    ( __param(9, IFilesConfigurationService)),
+    ( __param(10, ICodeEditorService)),
+    ( __param(11, IPathService)),
+    ( __param(12, IWorkingCopyFileService)),
+    ( __param(13, IUriIdentityService)),
+    ( __param(14, ILanguageService)),
+    ( __param(15, IElevatedFileService)),
+    ( __param(16, ILogService)),
+    ( __param(17, IDecorationsService))
+], BrowserTextFileService));
+export { BrowserTextFileService };