@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/common/languages/languageConfigurationRegistry.js

@@ -0,0 +1,337 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { getLeadingWhitespace } from '../../../base/common/strings.js';
+import { DEFAULT_WORD_REGEXP, ensureValidWordDefinition } from '../core/wordHelper.js';
+import { AutoClosingPairs } from './languageConfiguration.js';
+import { createScopedLineTokens } from './supports.js';
+import { CharacterPairSupport } from './supports/characterPair.js';
+import { BracketElectricCharacterSupport } from './supports/electricCharacter.js';
+import { IndentRulesSupport } from './supports/indentRules.js';
+import { OnEnterSupport } from './supports/onEnter.js';
+import { RichEditBrackets } from './supports/richEditBrackets.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
+import { ILanguageService } from './language.js';
+import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+import { PLAINTEXT_LANGUAGE_ID } from './modesRegistry.js';
+import { LanguageBracketsConfiguration } from './supports/languageBracketsConfiguration.js';
+class LanguageConfigurationServiceChangeEvent {
+    constructor(languageId) {
+        this.languageId = languageId;
+    }
+    affects(languageId) {
+        return !this.languageId ? true : this.languageId === languageId;
+    }
+}
+const ILanguageConfigurationService = ( createDecorator('languageConfigurationService'));
+let LanguageConfigurationService = class LanguageConfigurationService extends Disposable {
+    constructor(configurationService, languageService) {
+        super();
+        this.configurationService = configurationService;
+        this.languageService = languageService;
+        this._registry = this._register(( new LanguageConfigurationRegistry()));
+        this.onDidChangeEmitter = this._register(( new Emitter()));
+        this.onDidChange = this.onDidChangeEmitter.event;
+        this.configurations = ( new Map());
+        const languageConfigKeys = ( new Set(( Object.values(customizedLanguageConfigKeys))));
+        this._register(this.configurationService.onDidChangeConfiguration((e) => {
+            const globalConfigChanged = ( e.change.keys.some((k) => ( languageConfigKeys.has(k))));
+            const localConfigChanged = ( e.change.overrides
+                .filter(([overrideLangName, keys]) => ( keys.some((k) => ( languageConfigKeys.has(k)))))
+                .map(([overrideLangName]) => overrideLangName));
+            if (globalConfigChanged) {
+                this.configurations.clear();
+                this.onDidChangeEmitter.fire(( new LanguageConfigurationServiceChangeEvent(undefined)));
+            }
+            else {
+                for (const languageId of localConfigChanged) {
+                    if (this.languageService.isRegisteredLanguageId(languageId)) {
+                        this.configurations.delete(languageId);
+                        this.onDidChangeEmitter.fire(( new LanguageConfigurationServiceChangeEvent(languageId)));
+                    }
+                }
+            }
+        }));
+        this._register(this._registry.onDidChange((e) => {
+            this.configurations.delete(e.languageId);
+            this.onDidChangeEmitter.fire(( new LanguageConfigurationServiceChangeEvent(e.languageId)));
+        }));
+    }
+    register(languageId, configuration, priority) {
+        return this._registry.register(languageId, configuration, priority);
+    }
+    getLanguageConfiguration(languageId) {
+        let result = this.configurations.get(languageId);
+        if (!result) {
+            result = computeConfig(languageId, this._registry, this.configurationService, this.languageService);
+            this.configurations.set(languageId, result);
+        }
+        return result;
+    }
+};
+LanguageConfigurationService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ILanguageService))
+], LanguageConfigurationService));
+function computeConfig(languageId, registry, configurationService, languageService) {
+    let languageConfig = registry.getLanguageConfiguration(languageId);
+    if (!languageConfig) {
+        if (!languageService.isRegisteredLanguageId(languageId)) {
+            return ( new ResolvedLanguageConfiguration(languageId, {}));
+        }
+        languageConfig = ( new ResolvedLanguageConfiguration(languageId, {}));
+    }
+    const customizedConfig = getCustomizedLanguageConfig(languageConfig.languageId, configurationService);
+    const data = combineLanguageConfigurations([languageConfig.underlyingConfig, customizedConfig]);
+    const config = ( new ResolvedLanguageConfiguration(languageConfig.languageId, data));
+    return config;
+}
+const customizedLanguageConfigKeys = {
+    brackets: 'editor.language.brackets',
+    colorizedBracketPairs: 'editor.language.colorizedBracketPairs'
+};
+function getCustomizedLanguageConfig(languageId, configurationService) {
+    const brackets = configurationService.getValue(customizedLanguageConfigKeys.brackets, {
+        overrideIdentifier: languageId,
+    });
+    const colorizedBracketPairs = configurationService.getValue(customizedLanguageConfigKeys.colorizedBracketPairs, {
+        overrideIdentifier: languageId,
+    });
+    return {
+        brackets: validateBracketPairs(brackets),
+        colorizedBracketPairs: validateBracketPairs(colorizedBracketPairs),
+    };
+}
+function validateBracketPairs(data) {
+    if (!Array.isArray(data)) {
+        return undefined;
+    }
+    return ( data.map(pair => {
+        if (!Array.isArray(pair) || pair.length !== 2) {
+            return undefined;
+        }
+        return [pair[0], pair[1]];
+    })).filter((p) => !!p);
+}
+function getIndentationAtPosition(model, lineNumber, column) {
+    const lineText = model.getLineContent(lineNumber);
+    let indentation = getLeadingWhitespace(lineText);
+    if (indentation.length > column - 1) {
+        indentation = indentation.substring(0, column - 1);
+    }
+    return indentation;
+}
+function getScopedLineTokens(model, lineNumber, columnNumber) {
+    model.tokenization.forceTokenization(lineNumber);
+    const lineTokens = model.tokenization.getLineTokens(lineNumber);
+    const column = (typeof columnNumber === 'undefined' ? model.getLineMaxColumn(lineNumber) - 1 : columnNumber - 1);
+    return createScopedLineTokens(lineTokens, column);
+}
+class ComposedLanguageConfiguration {
+    constructor(languageId) {
+        this.languageId = languageId;
+        this._resolved = null;
+        this._entries = [];
+        this._order = 0;
+        this._resolved = null;
+    }
+    register(configuration, priority) {
+        const entry = ( new LanguageConfigurationContribution(configuration, priority, ++this._order));
+        this._entries.push(entry);
+        this._resolved = null;
+        return toDisposable(() => {
+            for (let i = 0; i < this._entries.length; i++) {
+                if (this._entries[i] === entry) {
+                    this._entries.splice(i, 1);
+                    this._resolved = null;
+                    break;
+                }
+            }
+        });
+    }
+    getResolvedConfiguration() {
+        if (!this._resolved) {
+            const config = this._resolve();
+            if (config) {
+                this._resolved = ( new ResolvedLanguageConfiguration(this.languageId, config));
+            }
+        }
+        return this._resolved;
+    }
+    _resolve() {
+        if (this._entries.length === 0) {
+            return null;
+        }
+        this._entries.sort(LanguageConfigurationContribution.cmp);
+        return combineLanguageConfigurations(( this._entries.map(e => e.configuration)));
+    }
+}
+function combineLanguageConfigurations(configs) {
+    let result = {
+        comments: undefined,
+        brackets: undefined,
+        wordPattern: undefined,
+        indentationRules: undefined,
+        onEnterRules: undefined,
+        autoClosingPairs: undefined,
+        surroundingPairs: undefined,
+        autoCloseBefore: undefined,
+        folding: undefined,
+        colorizedBracketPairs: undefined,
+        __electricCharacterSupport: undefined,
+    };
+    for (const entry of configs) {
+        result = {
+            comments: entry.comments || result.comments,
+            brackets: entry.brackets || result.brackets,
+            wordPattern: entry.wordPattern || result.wordPattern,
+            indentationRules: entry.indentationRules || result.indentationRules,
+            onEnterRules: entry.onEnterRules || result.onEnterRules,
+            autoClosingPairs: entry.autoClosingPairs || result.autoClosingPairs,
+            surroundingPairs: entry.surroundingPairs || result.surroundingPairs,
+            autoCloseBefore: entry.autoCloseBefore || result.autoCloseBefore,
+            folding: entry.folding || result.folding,
+            colorizedBracketPairs: entry.colorizedBracketPairs || result.colorizedBracketPairs,
+            __electricCharacterSupport: entry.__electricCharacterSupport || result.__electricCharacterSupport,
+        };
+    }
+    return result;
+}
+class LanguageConfigurationContribution {
+    constructor(configuration, priority, order) {
+        this.configuration = configuration;
+        this.priority = priority;
+        this.order = order;
+    }
+    static cmp(a, b) {
+        if (a.priority === b.priority) {
+            return a.order - b.order;
+        }
+        return a.priority - b.priority;
+    }
+}
+class LanguageConfigurationChangeEvent {
+    constructor(languageId) {
+        this.languageId = languageId;
+    }
+}
+class LanguageConfigurationRegistry extends Disposable {
+    constructor() {
+        super();
+        this._entries = ( new Map());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this.register(PLAINTEXT_LANGUAGE_ID, {
+            brackets: [
+                ['(', ')'],
+                ['[', ']'],
+                ['{', '}'],
+            ],
+            surroundingPairs: [
+                { open: '{', close: '}' },
+                { open: '[', close: ']' },
+                { open: '(', close: ')' },
+                { open: '<', close: '>' },
+                { open: '\"', close: '\"' },
+                { open: '\'', close: '\'' },
+                { open: '`', close: '`' },
+            ],
+            colorizedBracketPairs: [],
+            folding: {
+                offSide: true
+            }
+        }, 0));
+    }
+    register(languageId, configuration, priority = 0) {
+        let entries = this._entries.get(languageId);
+        if (!entries) {
+            entries = ( new ComposedLanguageConfiguration(languageId));
+            this._entries.set(languageId, entries);
+        }
+        const disposable = entries.register(configuration, priority);
+        this._onDidChange.fire(( new LanguageConfigurationChangeEvent(languageId)));
+        return toDisposable(() => {
+            disposable.dispose();
+            this._onDidChange.fire(( new LanguageConfigurationChangeEvent(languageId)));
+        });
+    }
+    getLanguageConfiguration(languageId) {
+        const entries = this._entries.get(languageId);
+        return entries?.getResolvedConfiguration() || null;
+    }
+}
+class ResolvedLanguageConfiguration {
+    constructor(languageId, underlyingConfig) {
+        this.languageId = languageId;
+        this.underlyingConfig = underlyingConfig;
+        this._brackets = null;
+        this._electricCharacter = null;
+        this._onEnterSupport =
+            this.underlyingConfig.brackets ||
+                this.underlyingConfig.indentationRules ||
+                this.underlyingConfig.onEnterRules
+                ? ( new OnEnterSupport(this.underlyingConfig))
+                : null;
+        this.comments = ResolvedLanguageConfiguration._handleComments(this.underlyingConfig);
+        this.characterPair = ( new CharacterPairSupport(this.underlyingConfig));
+        this.wordDefinition = this.underlyingConfig.wordPattern || DEFAULT_WORD_REGEXP;
+        this.indentationRules = this.underlyingConfig.indentationRules;
+        if (this.underlyingConfig.indentationRules) {
+            this.indentRulesSupport = ( new IndentRulesSupport(this.underlyingConfig.indentationRules));
+        }
+        else {
+            this.indentRulesSupport = null;
+        }
+        this.foldingRules = this.underlyingConfig.folding || {};
+        this.bracketsNew = ( new LanguageBracketsConfiguration(languageId, this.underlyingConfig));
+    }
+    getWordDefinition() {
+        return ensureValidWordDefinition(this.wordDefinition);
+    }
+    get brackets() {
+        if (!this._brackets && this.underlyingConfig.brackets) {
+            this._brackets = ( new RichEditBrackets(this.languageId, this.underlyingConfig.brackets));
+        }
+        return this._brackets;
+    }
+    get electricCharacter() {
+        if (!this._electricCharacter) {
+            this._electricCharacter = ( new BracketElectricCharacterSupport(this.brackets));
+        }
+        return this._electricCharacter;
+    }
+    onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText) {
+        if (!this._onEnterSupport) {
+            return null;
+        }
+        return this._onEnterSupport.onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText);
+    }
+    getAutoClosingPairs() {
+        return ( new AutoClosingPairs(this.characterPair.getAutoClosingPairs()));
+    }
+    getAutoCloseBeforeSet(forQuotes) {
+        return this.characterPair.getAutoCloseBeforeSet(forQuotes);
+    }
+    getSurroundingPairs() {
+        return this.characterPair.getSurroundingPairs();
+    }
+    static _handleComments(conf) {
+        const commentRule = conf.comments;
+        if (!commentRule) {
+            return null;
+        }
+        const comments = {};
+        if (commentRule.lineComment) {
+            comments.lineCommentToken = commentRule.lineComment;
+        }
+        if (commentRule.blockComment) {
+            const [blockStart, blockEnd] = commentRule.blockComment;
+            comments.blockCommentStartToken = blockStart;
+            comments.blockCommentEndToken = blockEnd;
+        }
+        return comments;
+    }
+}
+registerSingleton(ILanguageConfigurationService, LanguageConfigurationService, 1 );
+export { ILanguageConfigurationService, LanguageConfigurationChangeEvent, LanguageConfigurationRegistry, LanguageConfigurationService, LanguageConfigurationServiceChangeEvent, ResolvedLanguageConfiguration, getIndentationAtPosition, getScopedLineTokens };

package/vscode/src/vs/editor/common/languages/linkComputer.js

@@ -0,0 +1,245 @@
+import { CharacterClassifier } from '../core/characterClassifier.js';
+class Uint8Matrix {
+    constructor(rows, cols, defaultValue) {
+        const data = ( new Uint8Array(rows * cols));
+        for (let i = 0, len = rows * cols; i < len; i++) {
+            data[i] = defaultValue;
+        }
+        this._data = data;
+        this.rows = rows;
+        this.cols = cols;
+    }
+    get(row, col) {
+        return this._data[row * this.cols + col];
+    }
+    set(row, col, value) {
+        this._data[row * this.cols + col] = value;
+    }
+}
+class StateMachine {
+    constructor(edges) {
+        let maxCharCode = 0;
+        let maxState = 0 ;
+        for (let i = 0, len = edges.length; i < len; i++) {
+            const [from, chCode, to] = edges[i];
+            if (chCode > maxCharCode) {
+                maxCharCode = chCode;
+            }
+            if (from > maxState) {
+                maxState = from;
+            }
+            if (to > maxState) {
+                maxState = to;
+            }
+        }
+        maxCharCode++;
+        maxState++;
+        const states = ( new Uint8Matrix(maxState, maxCharCode, 0 ));
+        for (let i = 0, len = edges.length; i < len; i++) {
+            const [from, chCode, to] = edges[i];
+            states.set(from, chCode, to);
+        }
+        this._states = states;
+        this._maxCharCode = maxCharCode;
+    }
+    nextState(currentState, chCode) {
+        if (chCode < 0 || chCode >= this._maxCharCode) {
+            return 0 ;
+        }
+        return this._states.get(currentState, chCode);
+    }
+}
+let _stateMachine = null;
+function getStateMachine() {
+    if (_stateMachine === null) {
+        _stateMachine = ( new StateMachine([
+            [1 , 104 , 2 ],
+            [1 , 72 , 2 ],
+            [1 , 102 , 6 ],
+            [1 , 70 , 6 ],
+            [2 , 116 , 3 ],
+            [2 , 84 , 3 ],
+            [3 , 116 , 4 ],
+            [3 , 84 , 4 ],
+            [4 , 112 , 5 ],
+            [4 , 80 , 5 ],
+            [5 , 115 , 9 ],
+            [5 , 83 , 9 ],
+            [5 , 58 , 10 ],
+            [6 , 105 , 7 ],
+            [6 , 73 , 7 ],
+            [7 , 108 , 8 ],
+            [7 , 76 , 8 ],
+            [8 , 101 , 9 ],
+            [8 , 69 , 9 ],
+            [9 , 58 , 10 ],
+            [10 , 47 , 11 ],
+            [11 , 47 , 12 ],
+        ]));
+    }
+    return _stateMachine;
+}
+let _classifier = null;
+function getClassifier() {
+    if (_classifier === null) {
+        _classifier = ( new CharacterClassifier(0 ));
+        const FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';
+        for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {
+            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 );
+        }
+        const CANNOT_END_WITH_CHARACTERS = '.,;:';
+        for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {
+            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 );
+        }
+    }
+    return _classifier;
+}
+class LinkComputer {
+    static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {
+        let lastIncludedCharIndex = linkEndIndex - 1;
+        do {
+            const chCode = line.charCodeAt(lastIncludedCharIndex);
+            const chClass = classifier.get(chCode);
+            if (chClass !== 2 ) {
+                break;
+            }
+            lastIncludedCharIndex--;
+        } while (lastIncludedCharIndex > linkBeginIndex);
+        if (linkBeginIndex > 0) {
+            const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);
+            const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);
+            if (((charCodeBeforeLink === 40  && lastCharCodeInLink === 41) )
+                || ((charCodeBeforeLink === 91  && lastCharCodeInLink === 93) )
+                || ((charCodeBeforeLink === 123  && lastCharCodeInLink === 125) )) {
+                lastIncludedCharIndex--;
+            }
+        }
+        return {
+            range: {
+                startLineNumber: lineNumber,
+                startColumn: linkBeginIndex + 1,
+                endLineNumber: lineNumber,
+                endColumn: lastIncludedCharIndex + 2
+            },
+            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)
+        };
+    }
+    static computeLinks(model, stateMachine = getStateMachine()) {
+        const classifier = getClassifier();
+        const result = [];
+        for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {
+            const line = model.getLineContent(i);
+            const len = line.length;
+            let j = 0;
+            let linkBeginIndex = 0;
+            let linkBeginChCode = 0;
+            let state = 1 ;
+            let hasOpenParens = false;
+            let hasOpenSquareBracket = false;
+            let inSquareBrackets = false;
+            let hasOpenCurlyBracket = false;
+            while (j < len) {
+                let resetStateMachine = false;
+                const chCode = line.charCodeAt(j);
+                if (state === 13 ) {
+                    let chClass;
+                    switch (chCode) {
+                        case 40 :
+                            hasOpenParens = true;
+                            chClass = 0 ;
+                            break;
+                        case 41 :
+                            chClass = ((hasOpenParens ? 0  : 1) );
+                            break;
+                        case 91 :
+                            inSquareBrackets = true;
+                            hasOpenSquareBracket = true;
+                            chClass = 0 ;
+                            break;
+                        case 93 :
+                            inSquareBrackets = false;
+                            chClass = ((hasOpenSquareBracket ? 0  : 1) );
+                            break;
+                        case 123 :
+                            hasOpenCurlyBracket = true;
+                            chClass = 0 ;
+                            break;
+                        case 125 :
+                            chClass = ((hasOpenCurlyBracket ? 0  : 1) );
+                            break;
+                        case 39 :
+                        case 34 :
+                        case 96 :
+                            if (linkBeginChCode === chCode) {
+                                chClass = 1 ;
+                            }
+                            else if (linkBeginChCode === 39  || linkBeginChCode === 34  || linkBeginChCode === 96 ) {
+                                chClass = 0 ;
+                            }
+                            else {
+                                chClass = 1 ;
+                            }
+                            break;
+                        case 42 :
+                            chClass = ((linkBeginChCode === 42) ) ? 1  : 0 ;
+                            break;
+                        case 124 :
+                            chClass = ((linkBeginChCode === 124) ) ? 1  : 0 ;
+                            break;
+                        case 32 :
+                            chClass = ((inSquareBrackets ? 0  : 1) );
+                            break;
+                        default:
+                            chClass = classifier.get(chCode);
+                    }
+                    if (chClass === 1 ) {
+                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));
+                        resetStateMachine = true;
+                    }
+                }
+                else if (state === 12 ) {
+                    let chClass;
+                    if (chCode === 91 ) {
+                        hasOpenSquareBracket = true;
+                        chClass = 0 ;
+                    }
+                    else {
+                        chClass = classifier.get(chCode);
+                    }
+                    if (chClass === 1 ) {
+                        resetStateMachine = true;
+                    }
+                    else {
+                        state = 13 ;
+                    }
+                }
+                else {
+                    state = stateMachine.nextState(state, chCode);
+                    if (state === 0 ) {
+                        resetStateMachine = true;
+                    }
+                }
+                if (resetStateMachine) {
+                    state = 1 ;
+                    hasOpenParens = false;
+                    hasOpenSquareBracket = false;
+                    hasOpenCurlyBracket = false;
+                    linkBeginIndex = j + 1;
+                    linkBeginChCode = chCode;
+                }
+                j++;
+            }
+            if (state === 13 ) {
+                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));
+            }
+        }
+        return result;
+    }
+}
+function computeLinks(model) {
+    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {
+        return [];
+    }
+    return LinkComputer.computeLinks(model);
+}
+export { LinkComputer, StateMachine, computeLinks };

package/vscode/src/vs/editor/common/languages/modesRegistry.js

@@ -0,0 +1,56 @@
+import { localizeWithPath } from '../../../nls.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Registry } from '../../../platform/registry/common/platform.js';
+import { Mimes } from '../../../base/common/mime.js';
+import { Extensions as Extensions$1 } from '../../../platform/configuration/common/configurationRegistry.js';
+const Extensions = {
+    ModesRegistry: 'editor.modesRegistry'
+};
+class EditorModesRegistry {
+    constructor() {
+        this._onDidChangeLanguages = ( new Emitter());
+        this.onDidChangeLanguages = this._onDidChangeLanguages.event;
+        this._languages = [];
+    }
+    registerLanguage(def) {
+        this._languages.push(def);
+        this._onDidChangeLanguages.fire(undefined);
+        return {
+            dispose: () => {
+                for (let i = 0, len = this._languages.length; i < len; i++) {
+                    if (this._languages[i] === def) {
+                        this._languages.splice(i, 1);
+                        return;
+                    }
+                }
+            }
+        };
+    }
+    getLanguages() {
+        return this._languages;
+    }
+}
+const ModesRegistry = ( new EditorModesRegistry());
+Registry.add(Extensions.ModesRegistry, ModesRegistry);
+const PLAINTEXT_LANGUAGE_ID = 'plaintext';
+const PLAINTEXT_EXTENSION = '.txt';
+ModesRegistry.registerLanguage({
+    id: PLAINTEXT_LANGUAGE_ID,
+    extensions: [PLAINTEXT_EXTENSION],
+    aliases: [( localizeWithPath(
+        'vs/editor/common/languages/modesRegistry',
+        'plainText.alias',
+        "Plain Text"
+    )), 'text'],
+    mimetypes: [Mimes.text]
+});
+( Registry.as(Extensions$1.Configuration))
+    .registerDefaultConfigurations([{
+        overrides: {
+            '[plaintext]': {
+                'editor.unicodeHighlight.ambiguousCharacters': false,
+                'editor.unicodeHighlight.invisibleCharacters': false
+            }
+        }
+    }]);
+export { EditorModesRegistry, Extensions, ModesRegistry, PLAINTEXT_EXTENSION, PLAINTEXT_LANGUAGE_ID };

package/vscode/src/vs/editor/common/languages/nullTokenize.js

@@ -0,0 +1,23 @@
+import { EncodedTokenizationResult, TokenizationResult, Token } from '../languages.js';
+const NullState = new class {
+    clone() {
+        return this;
+    }
+    equals(other) {
+        return (this === other);
+    }
+};
+function nullTokenize(languageId, state) {
+    return ( new TokenizationResult([( new Token(0, '', languageId))], state));
+}
+function nullTokenizeEncoded(languageId, state) {
+    const tokens = ( new Uint32Array(2));
+    tokens[0] = 0;
+    tokens[1] = (((languageId << 0) )
+        | ((0  << 8) )
+        | ((0  << 11) )
+        | ((1  << 15) )
+        | ((2  << 24) )) >>> 0;
+    return ( new EncodedTokenizationResult(tokens, state === null ? NullState : state));
+}
+export { NullState, nullTokenize, nullTokenizeEncoded };