monaco-editor11 1.0.9 → 1.1.0

package/dist/workers/editor/common/language.js

@@ -1,9 +0,0 @@
-import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const ILanguageService = createDecorator('languageService');
-
-export { ILanguageService };

package/dist/workers/editor/common/languageBracketsConfiguration.js

@@ -1,133 +0,0 @@
-import { CachedFunction } from '../../../../base/common/cache.js';
-import { createBracketOrRegExp } from './richEditBrackets.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Captures all bracket related configurations for a single language.
- * Immutable.
-*/
-class LanguageBracketsConfiguration {
-    constructor(languageId, config) {
-        this.languageId = languageId;
-        const bracketPairs = config.brackets ? filterValidBrackets(config.brackets) : [];
-        const openingBracketInfos = new CachedFunction((bracket) => {
-            const closing = new Set();
-            return {
-                info: new OpeningBracketKind(this, bracket, closing),
-                closing,
-            };
-        });
-        const closingBracketInfos = new CachedFunction((bracket) => {
-            const opening = new Set();
-            const openingColorized = new Set();
-            return {
-                info: new ClosingBracketKind(this, bracket, opening, openingColorized),
-                opening,
-                openingColorized,
-            };
-        });
-        for (const [open, close] of bracketPairs) {
-            const opening = openingBracketInfos.get(open);
-            const closing = closingBracketInfos.get(close);
-            opening.closing.add(closing.info);
-            closing.opening.add(opening.info);
-        }
-        // Treat colorized brackets as brackets, and mark them as colorized.
-        const colorizedBracketPairs = config.colorizedBracketPairs
-            ? filterValidBrackets(config.colorizedBracketPairs)
-            // If not configured: Take all brackets except `<` ... `>`
-            // Many languages set < ... > as bracket pair, even though they also use it as comparison operator.
-            // This leads to problems when colorizing this bracket, so we exclude it if not explicitly configured otherwise.
-            // https://github.com/microsoft/vscode/issues/132476
-            : bracketPairs.filter((p) => !(p[0] === '<' && p[1] === '>'));
-        for (const [open, close] of colorizedBracketPairs) {
-            const opening = openingBracketInfos.get(open);
-            const closing = closingBracketInfos.get(close);
-            opening.closing.add(closing.info);
-            closing.openingColorized.add(opening.info);
-            closing.opening.add(opening.info);
-        }
-        this._openingBrackets = new Map([...openingBracketInfos.cachedValues].map(([k, v]) => [k, v.info]));
-        this._closingBrackets = new Map([...closingBracketInfos.cachedValues].map(([k, v]) => [k, v.info]));
-    }
-    /**
-     * No two brackets have the same bracket text.
-    */
-    get openingBrackets() {
-        return [...this._openingBrackets.values()];
-    }
-    /**
-     * No two brackets have the same bracket text.
-    */
-    get closingBrackets() {
-        return [...this._closingBrackets.values()];
-    }
-    getOpeningBracketInfo(bracketText) {
-        return this._openingBrackets.get(bracketText);
-    }
-    getClosingBracketInfo(bracketText) {
-        return this._closingBrackets.get(bracketText);
-    }
-    getBracketInfo(bracketText) {
-        return this.getOpeningBracketInfo(bracketText) || this.getClosingBracketInfo(bracketText);
-    }
-    getBracketRegExp(options) {
-        const brackets = Array.from([...this._openingBrackets.keys(), ...this._closingBrackets.keys()]);
-        return createBracketOrRegExp(brackets, options);
-    }
-}
-function filterValidBrackets(bracketPairs) {
-    return bracketPairs.filter(([open, close]) => open !== '' && close !== '');
-}
-class BracketKindBase {
-    constructor(config, bracketText) {
-        this.config = config;
-        this.bracketText = bracketText;
-    }
-    get languageId() {
-        return this.config.languageId;
-    }
-}
-class OpeningBracketKind extends BracketKindBase {
-    constructor(config, bracketText, openedBrackets) {
-        super(config, bracketText);
-        this.openedBrackets = openedBrackets;
-        this.isOpeningBracket = true;
-    }
-}
-class ClosingBracketKind extends BracketKindBase {
-    constructor(config, bracketText, 
-    /**
-     * Non empty array of all opening brackets this bracket closes.
-    */
-    openingBrackets, openingColorizedBrackets) {
-        super(config, bracketText);
-        this.openingBrackets = openingBrackets;
-        this.openingColorizedBrackets = openingColorizedBrackets;
-        this.isOpeningBracket = false;
-    }
-    /**
-     * Checks if this bracket closes the given other bracket.
-     * If the bracket infos come from different configurations, this method will return false.
-    */
-    closes(other) {
-        if (other['config'] !== this.config) {
-            return false;
-        }
-        return this.openingBrackets.has(other);
-    }
-    closesColorized(other) {
-        if (other['config'] !== this.config) {
-            return false;
-        }
-        return this.openingColorizedBrackets.has(other);
-    }
-    getOpeningBrackets() {
-        return [...this.openingBrackets];
-    }
-}
-
-export { BracketKindBase, ClosingBracketKind, LanguageBracketsConfiguration, OpeningBracketKind };

package/dist/workers/editor/common/languageConfiguration.js

@@ -1,138 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Describes what to do with the indentation when pressing Enter.
- */
-var IndentAction;
-(function (IndentAction) {
-    /**
-     * Insert new line and copy the previous line's indentation.
-     */
-    IndentAction[IndentAction["None"] = 0] = "None";
-    /**
-     * Insert new line and indent once (relative to the previous line's indentation).
-     */
-    IndentAction[IndentAction["Indent"] = 1] = "Indent";
-    /**
-     * Insert two new lines:
-     *  - the first one indented which will hold the cursor
-     *  - the second one at the same indentation level
-     */
-    IndentAction[IndentAction["IndentOutdent"] = 2] = "IndentOutdent";
-    /**
-     * Insert new line and outdent once (relative to the previous line's indentation).
-     */
-    IndentAction[IndentAction["Outdent"] = 3] = "Outdent";
-})(IndentAction || (IndentAction = {}));
-/**
- * @internal
- */
-class StandardAutoClosingPairConditional {
-    constructor(source) {
-        this._neutralCharacter = null;
-        this._neutralCharacterSearched = false;
-        this.open = source.open;
-        this.close = source.close;
-        // initially allowed in all tokens
-        this._inString = true;
-        this._inComment = true;
-        this._inRegEx = true;
-        if (Array.isArray(source.notIn)) {
-            for (let i = 0, len = source.notIn.length; i < len; i++) {
-                const notIn = source.notIn[i];
-                switch (notIn) {
-                    case 'string':
-                        this._inString = false;
-                        break;
-                    case 'comment':
-                        this._inComment = false;
-                        break;
-                    case 'regex':
-                        this._inRegEx = false;
-                        break;
-                }
-            }
-        }
-    }
-    isOK(standardToken) {
-        switch (standardToken) {
-            case 0 /* StandardTokenType.Other */:
-                return true;
-            case 1 /* StandardTokenType.Comment */:
-                return this._inComment;
-            case 2 /* StandardTokenType.String */:
-                return this._inString;
-            case 3 /* StandardTokenType.RegEx */:
-                return this._inRegEx;
-        }
-    }
-    shouldAutoClose(context, column) {
-        // Always complete on empty line
-        if (context.getTokenCount() === 0) {
-            return true;
-        }
-        const tokenIndex = context.findTokenIndexAtOffset(column - 2);
-        const standardTokenType = context.getStandardTokenType(tokenIndex);
-        return this.isOK(standardTokenType);
-    }
-    _findNeutralCharacterInRange(fromCharCode, toCharCode) {
-        for (let charCode = fromCharCode; charCode <= toCharCode; charCode++) {
-            const character = String.fromCharCode(charCode);
-            if (!this.open.includes(character) && !this.close.includes(character)) {
-                return character;
-            }
-        }
-        return null;
-    }
-    /**
-     * Find a character in the range [0-9a-zA-Z] that does not appear in the open or close
-     */
-    findNeutralCharacter() {
-        if (!this._neutralCharacterSearched) {
-            this._neutralCharacterSearched = true;
-            if (!this._neutralCharacter) {
-                this._neutralCharacter = this._findNeutralCharacterInRange(48 /* CharCode.Digit0 */, 57 /* CharCode.Digit9 */);
-            }
-            if (!this._neutralCharacter) {
-                this._neutralCharacter = this._findNeutralCharacterInRange(97 /* CharCode.a */, 122 /* CharCode.z */);
-            }
-            if (!this._neutralCharacter) {
-                this._neutralCharacter = this._findNeutralCharacterInRange(65 /* CharCode.A */, 90 /* CharCode.Z */);
-            }
-        }
-        return this._neutralCharacter;
-    }
-}
-/**
- * @internal
- */
-class AutoClosingPairs {
-    constructor(autoClosingPairs) {
-        this.autoClosingPairsOpenByStart = new Map();
-        this.autoClosingPairsOpenByEnd = new Map();
-        this.autoClosingPairsCloseByStart = new Map();
-        this.autoClosingPairsCloseByEnd = new Map();
-        this.autoClosingPairsCloseSingleChar = new Map();
-        for (const pair of autoClosingPairs) {
-            appendEntry(this.autoClosingPairsOpenByStart, pair.open.charAt(0), pair);
-            appendEntry(this.autoClosingPairsOpenByEnd, pair.open.charAt(pair.open.length - 1), pair);
-            appendEntry(this.autoClosingPairsCloseByStart, pair.close.charAt(0), pair);
-            appendEntry(this.autoClosingPairsCloseByEnd, pair.close.charAt(pair.close.length - 1), pair);
-            if (pair.close.length === 1 && pair.open.length === 1) {
-                appendEntry(this.autoClosingPairsCloseSingleChar, pair.close, pair);
-            }
-        }
-    }
-}
-function appendEntry(target, key, value) {
-    if (target.has(key)) {
-        target.get(key).push(value);
-    }
-    else {
-        target.set(key, [value]);
-    }
-}
-
-export { AutoClosingPairs, IndentAction, StandardAutoClosingPairConditional };

package/dist/workers/editor/common/languageConfigurationRegistry.js

@@ -1,361 +0,0 @@
-import { Emitter } from '../../../base/common/event.js';
-import { Disposable, markAsSingleton, 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 { 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';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-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)) {
-            // this happens for the null language, which can be returned by monarch.
-            // Instead of throwing an error, we just return a default config.
-            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;
-}
-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 markAsSingleton(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) {
-            // higher order last
-            return a.order - b.order;
-        }
-        // higher priority last
-        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));
-    }
-    /**
-     * @param priority Use a higher number for higher priority
-     */
-    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 markAsSingleton(toDisposable(() => {
-            disposable.dispose();
-            this._onDidChange.fire(new LanguageConfigurationChangeEvent(languageId));
-        }));
-    }
-    getLanguageConfiguration(languageId) {
-        const entries = this._entries.get(languageId);
-        return entries?.getResolvedConfiguration() || null;
-    }
-}
-/**
- * Immutable.
-*/
-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;
-        }
-        // comment configuration
-        const comments = {};
-        if (commentRule.lineComment) {
-            if (typeof commentRule.lineComment === 'string') {
-                comments.lineCommentToken = commentRule.lineComment;
-            }
-            else {
-                comments.lineCommentToken = commentRule.lineComment.comment;
-                comments.lineCommentNoIndent = commentRule.lineComment.noIndent;
-            }
-        }
-        if (commentRule.blockComment) {
-            const [blockStart, blockEnd] = commentRule.blockComment;
-            comments.blockCommentStartToken = blockStart;
-            comments.blockCommentEndToken = blockEnd;
-        }
-        return comments;
-    }
-}
-registerSingleton(ILanguageConfigurationService, LanguageConfigurationService, 1 /* InstantiationType.Delayed */);
-
-export { ILanguageConfigurationService, LanguageConfigurationChangeEvent, LanguageConfigurationRegistry, LanguageConfigurationService, LanguageConfigurationServiceChangeEvent, ResolvedLanguageConfiguration, getIndentationAtPosition };