monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,343 +0,0 @@
-import { Emitter } from '../../../../../base/common/event.js';
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import { BracketInfo, BracketPairWithMinIndentationInfo } from '../../../textModelBracketPairs.js';
-import { TextEditInfo } from './beforeEditPositionMapper.js';
-import { LanguageAgnosticBracketTokens } from './brackets.js';
-import { toLength, lengthZero, positionToLength, lengthsToRange, lengthAdd, lengthLessThanEqual, lengthGreaterThanEqual, lengthLessThan } from './length.js';
-import { parseDocument } from './parser.js';
-import { DenseKeyProvider } from './smallImmutableSet.js';
-import { FastTokenizer, TextBufferTokenizer } from './tokenizer.js';
-import { CallbackIterable } from '../../../../../base/common/arrays.js';
-import { combineTextEditInfos } from './combineTextEditInfos.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class BracketPairsTree extends Disposable {
-    didLanguageChange(languageId) {
-        return this.brackets.didLanguageChange(languageId);
-    }
-    constructor(textModel, getLanguageConfiguration) {
-        super();
-        this.textModel = textModel;
-        this.getLanguageConfiguration = getLanguageConfiguration;
-        this.didChangeEmitter = new Emitter();
-        this.denseKeyProvider = new DenseKeyProvider();
-        this.brackets = new LanguageAgnosticBracketTokens(this.denseKeyProvider, this.getLanguageConfiguration);
-        this.onDidChange = this.didChangeEmitter.event;
-        this.queuedTextEditsForInitialAstWithoutTokens = [];
-        this.queuedTextEdits = [];
-        if (!textModel.tokenization.hasTokens) {
-            const brackets = this.brackets.getSingleLanguageBracketTokens(this.textModel.getLanguageId());
-            const tokenizer = new FastTokenizer(this.textModel.getValue(), brackets);
-            this.initialAstWithoutTokens = parseDocument(tokenizer, [], undefined, true);
-            this.astWithTokens = this.initialAstWithoutTokens;
-        }
-        else if (textModel.tokenization.backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {
-            // Skip the initial ast, as there is no flickering.
-            // Directly create the tree with token information.
-            this.initialAstWithoutTokens = undefined;
-            this.astWithTokens = this.parseDocumentFromTextBuffer([], undefined, false);
-        }
-        else {
-            // We missed some token changes already, so we cannot use the fast tokenizer + delta increments
-            this.initialAstWithoutTokens = this.parseDocumentFromTextBuffer([], undefined, true);
-            this.astWithTokens = this.initialAstWithoutTokens;
-        }
-    }
-    //#region TextModel events
-    handleDidChangeBackgroundTokenizationState() {
-        if (this.textModel.tokenization.backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {
-            const wasUndefined = this.initialAstWithoutTokens === undefined;
-            // Clear the initial tree as we can use the tree with token information now.
-            this.initialAstWithoutTokens = undefined;
-            if (!wasUndefined) {
-                this.didChangeEmitter.fire();
-            }
-        }
-    }
-    handleDidChangeTokens({ ranges }) {
-        const edits = ranges.map(r => new TextEditInfo(toLength(r.fromLineNumber - 1, 0), toLength(r.toLineNumber, 0), toLength(r.toLineNumber - r.fromLineNumber + 1, 0)));
-        this.handleEdits(edits, true);
-        if (!this.initialAstWithoutTokens) {
-            this.didChangeEmitter.fire();
-        }
-    }
-    handleContentChanged(change) {
-        const edits = TextEditInfo.fromModelContentChanges(change.changes);
-        this.handleEdits(edits, false);
-    }
-    handleEdits(edits, tokenChange) {
-        // Lazily queue the edits and only apply them when the tree is accessed.
-        const result = combineTextEditInfos(this.queuedTextEdits, edits);
-        this.queuedTextEdits = result;
-        if (this.initialAstWithoutTokens && !tokenChange) {
-            this.queuedTextEditsForInitialAstWithoutTokens = combineTextEditInfos(this.queuedTextEditsForInitialAstWithoutTokens, edits);
-        }
-    }
-    //#endregion
-    flushQueue() {
-        if (this.queuedTextEdits.length > 0) {
-            this.astWithTokens = this.parseDocumentFromTextBuffer(this.queuedTextEdits, this.astWithTokens, false);
-            this.queuedTextEdits = [];
-        }
-        if (this.queuedTextEditsForInitialAstWithoutTokens.length > 0) {
-            if (this.initialAstWithoutTokens) {
-                this.initialAstWithoutTokens = this.parseDocumentFromTextBuffer(this.queuedTextEditsForInitialAstWithoutTokens, this.initialAstWithoutTokens, false);
-            }
-            this.queuedTextEditsForInitialAstWithoutTokens = [];
-        }
-    }
-    /**
-     * @pure (only if isPure = true)
-    */
-    parseDocumentFromTextBuffer(edits, previousAst, immutable) {
-        const previousAstClone = previousAst;
-        const tokenizer = new TextBufferTokenizer(this.textModel, this.brackets);
-        const result = parseDocument(tokenizer, edits, previousAstClone, immutable);
-        return result;
-    }
-    getBracketsInRange(range, onlyColorizedBrackets) {
-        this.flushQueue();
-        const startOffset = toLength(range.startLineNumber - 1, range.startColumn - 1);
-        const endOffset = toLength(range.endLineNumber - 1, range.endColumn - 1);
-        return new CallbackIterable(cb => {
-            const node = this.initialAstWithoutTokens || this.astWithTokens;
-            collectBrackets(node, lengthZero, node.length, startOffset, endOffset, cb, 0, 0, new Map(), onlyColorizedBrackets);
-        });
-    }
-    getBracketPairsInRange(range, includeMinIndentation) {
-        this.flushQueue();
-        const startLength = positionToLength(range.getStartPosition());
-        const endLength = positionToLength(range.getEndPosition());
-        return new CallbackIterable(cb => {
-            const node = this.initialAstWithoutTokens || this.astWithTokens;
-            const context = new CollectBracketPairsContext(cb, includeMinIndentation, this.textModel);
-            collectBracketPairs(node, lengthZero, node.length, startLength, endLength, context, 0, new Map());
-        });
-    }
-    getFirstBracketAfter(position) {
-        this.flushQueue();
-        const node = this.initialAstWithoutTokens || this.astWithTokens;
-        return getFirstBracketAfter(node, lengthZero, node.length, positionToLength(position));
-    }
-    getFirstBracketBefore(position) {
-        this.flushQueue();
-        const node = this.initialAstWithoutTokens || this.astWithTokens;
-        return getFirstBracketBefore(node, lengthZero, node.length, positionToLength(position));
-    }
-}
-function getFirstBracketBefore(node, nodeOffsetStart, nodeOffsetEnd, position) {
-    if (node.kind === 4 /* AstNodeKind.List */ || node.kind === 2 /* AstNodeKind.Pair */) {
-        const lengths = [];
-        for (const child of node.children) {
-            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
-            lengths.push({ nodeOffsetStart, nodeOffsetEnd });
-            nodeOffsetStart = nodeOffsetEnd;
-        }
-        for (let i = lengths.length - 1; i >= 0; i--) {
-            const { nodeOffsetStart, nodeOffsetEnd } = lengths[i];
-            if (lengthLessThan(nodeOffsetStart, position)) {
-                const result = getFirstBracketBefore(node.children[i], nodeOffsetStart, nodeOffsetEnd, position);
-                if (result) {
-                    return result;
-                }
-            }
-        }
-        return null;
-    }
-    else if (node.kind === 3 /* AstNodeKind.UnexpectedClosingBracket */) {
-        return null;
-    }
-    else if (node.kind === 1 /* AstNodeKind.Bracket */) {
-        const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
-        return {
-            bracketInfo: node.bracketInfo,
-            range
-        };
-    }
-    return null;
-}
-function getFirstBracketAfter(node, nodeOffsetStart, nodeOffsetEnd, position) {
-    if (node.kind === 4 /* AstNodeKind.List */ || node.kind === 2 /* AstNodeKind.Pair */) {
-        for (const child of node.children) {
-            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
-            if (lengthLessThan(position, nodeOffsetEnd)) {
-                const result = getFirstBracketAfter(child, nodeOffsetStart, nodeOffsetEnd, position);
-                if (result) {
-                    return result;
-                }
-            }
-            nodeOffsetStart = nodeOffsetEnd;
-        }
-        return null;
-    }
-    else if (node.kind === 3 /* AstNodeKind.UnexpectedClosingBracket */) {
-        return null;
-    }
-    else if (node.kind === 1 /* AstNodeKind.Bracket */) {
-        const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
-        return {
-            bracketInfo: node.bracketInfo,
-            range
-        };
-    }
-    return null;
-}
-function collectBrackets(node, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, level, nestingLevelOfEqualBracketType, levelPerBracketType, onlyColorizedBrackets, parentPairIsIncomplete = false) {
-    if (level > 200) {
-        return true;
-    }
-    whileLoop: while (true) {
-        switch (node.kind) {
-            case 4 /* AstNodeKind.List */: {
-                const childCount = node.childrenLength;
-                for (let i = 0; i < childCount; i++) {
-                    const child = node.getChild(i);
-                    if (!child) {
-                        continue;
-                    }
-                    nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
-                    if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&
-                        lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {
-                        const childEndsAfterEnd = lengthGreaterThanEqual(nodeOffsetEnd, endOffset);
-                        if (childEndsAfterEnd) {
-                            // No child after this child in the requested window, don't recurse
-                            node = child;
-                            continue whileLoop;
-                        }
-                        const shouldContinue = collectBrackets(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, level, 0, levelPerBracketType, onlyColorizedBrackets);
-                        if (!shouldContinue) {
-                            return false;
-                        }
-                    }
-                    nodeOffsetStart = nodeOffsetEnd;
-                }
-                return true;
-            }
-            case 2 /* AstNodeKind.Pair */: {
-                const colorize = !onlyColorizedBrackets || !node.closingBracket || node.closingBracket.bracketInfo.closesColorized(node.openingBracket.bracketInfo);
-                let levelPerBracket = 0;
-                if (levelPerBracketType) {
-                    let existing = levelPerBracketType.get(node.openingBracket.text);
-                    if (existing === undefined) {
-                        existing = 0;
-                    }
-                    levelPerBracket = existing;
-                    if (colorize) {
-                        existing++;
-                        levelPerBracketType.set(node.openingBracket.text, existing);
-                    }
-                }
-                const childCount = node.childrenLength;
-                for (let i = 0; i < childCount; i++) {
-                    const child = node.getChild(i);
-                    if (!child) {
-                        continue;
-                    }
-                    nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
-                    if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&
-                        lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {
-                        const childEndsAfterEnd = lengthGreaterThanEqual(nodeOffsetEnd, endOffset);
-                        if (childEndsAfterEnd && child.kind !== 1 /* AstNodeKind.Bracket */) {
-                            // No child after this child in the requested window, don't recurse
-                            // Don't do this for brackets because of unclosed/unopened brackets
-                            node = child;
-                            if (colorize) {
-                                level++;
-                                nestingLevelOfEqualBracketType = levelPerBracket + 1;
-                            }
-                            else {
-                                nestingLevelOfEqualBracketType = levelPerBracket;
-                            }
-                            continue whileLoop;
-                        }
-                        if (colorize || child.kind !== 1 /* AstNodeKind.Bracket */ || !node.closingBracket) {
-                            const shouldContinue = collectBrackets(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, push, colorize ? level + 1 : level, colorize ? levelPerBracket + 1 : levelPerBracket, levelPerBracketType, onlyColorizedBrackets, !node.closingBracket);
-                            if (!shouldContinue) {
-                                return false;
-                            }
-                        }
-                    }
-                    nodeOffsetStart = nodeOffsetEnd;
-                }
-                levelPerBracketType?.set(node.openingBracket.text, levelPerBracket);
-                return true;
-            }
-            case 3 /* AstNodeKind.UnexpectedClosingBracket */: {
-                const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
-                return push(new BracketInfo(range, level - 1, 0, true));
-            }
-            case 1 /* AstNodeKind.Bracket */: {
-                const range = lengthsToRange(nodeOffsetStart, nodeOffsetEnd);
-                return push(new BracketInfo(range, level - 1, nestingLevelOfEqualBracketType - 1, parentPairIsIncomplete));
-            }
-            case 0 /* AstNodeKind.Text */:
-                return true;
-        }
-    }
-}
-class CollectBracketPairsContext {
-    constructor(push, includeMinIndentation, textModel) {
-        this.push = push;
-        this.includeMinIndentation = includeMinIndentation;
-        this.textModel = textModel;
-    }
-}
-function collectBracketPairs(node, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, context, level, levelPerBracketType) {
-    if (level > 200) {
-        return true;
-    }
-    let shouldContinue = true;
-    if (node.kind === 2 /* AstNodeKind.Pair */) {
-        let levelPerBracket = 0;
-        if (levelPerBracketType) {
-            let existing = levelPerBracketType.get(node.openingBracket.text);
-            if (existing === undefined) {
-                existing = 0;
-            }
-            levelPerBracket = existing;
-            existing++;
-            levelPerBracketType.set(node.openingBracket.text, existing);
-        }
-        const openingBracketEnd = lengthAdd(nodeOffsetStart, node.openingBracket.length);
-        let minIndentation = -1;
-        if (context.includeMinIndentation) {
-            minIndentation = node.computeMinIndentation(nodeOffsetStart, context.textModel);
-        }
-        shouldContinue = context.push(new BracketPairWithMinIndentationInfo(lengthsToRange(nodeOffsetStart, nodeOffsetEnd), lengthsToRange(nodeOffsetStart, openingBracketEnd), node.closingBracket
-            ? lengthsToRange(lengthAdd(openingBracketEnd, node.child?.length || lengthZero), nodeOffsetEnd)
-            : undefined, level, levelPerBracket, node, minIndentation));
-        nodeOffsetStart = openingBracketEnd;
-        if (shouldContinue && node.child) {
-            const child = node.child;
-            nodeOffsetEnd = lengthAdd(nodeOffsetStart, child.length);
-            if (lengthLessThanEqual(nodeOffsetStart, endOffset) &&
-                lengthGreaterThanEqual(nodeOffsetEnd, startOffset)) {
-                shouldContinue = collectBracketPairs(child, nodeOffsetStart, nodeOffsetEnd, startOffset, endOffset, context, level + 1, levelPerBracketType);
-                if (!shouldContinue) {
-                    return false;
-                }
-            }
-        }
-        levelPerBracketType?.set(node.openingBracket.text, levelPerBracket);
-    }
-    else {
-        let curOffset = nodeOffsetStart;
-        for (const child of node.children) {
-            const childOffset = curOffset;
-            curOffset = lengthAdd(curOffset, child.length);
-            if (lengthLessThanEqual(childOffset, endOffset) &&
-                lengthLessThanEqual(startOffset, curOffset)) {
-                shouldContinue = collectBracketPairs(child, childOffset, curOffset, startOffset, endOffset, context, level, levelPerBracketType);
-                if (!shouldContinue) {
-                    return false;
-                }
-            }
-        }
-    }
-    return shouldContinue;
-}
-
-export { BracketPairsTree };

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

@@ -1,108 +0,0 @@
-import { escapeRegExpCharacters } from '../../../../../base/common/strings.js';
-import { BracketAstNode } from './ast.js';
-import { toLength } from './length.js';
-import { SmallImmutableSet, identityKeyProvider } from './smallImmutableSet.js';
-import { Token } from './tokenizer.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class BracketTokens {
-    static createFromLanguage(configuration, denseKeyProvider) {
-        function getId(bracketInfo) {
-            return denseKeyProvider.getKey(`${bracketInfo.languageId}:::${bracketInfo.bracketText}`);
-        }
-        const map = new Map();
-        for (const openingBracket of configuration.bracketsNew.openingBrackets) {
-            const length = toLength(0, openingBracket.bracketText.length);
-            const openingTextId = getId(openingBracket);
-            const bracketIds = SmallImmutableSet.getEmpty().add(openingTextId, identityKeyProvider);
-            map.set(openingBracket.bracketText, new Token(length, 1 /* TokenKind.OpeningBracket */, openingTextId, bracketIds, BracketAstNode.create(length, openingBracket, bracketIds)));
-        }
-        for (const closingBracket of configuration.bracketsNew.closingBrackets) {
-            const length = toLength(0, closingBracket.bracketText.length);
-            let bracketIds = SmallImmutableSet.getEmpty();
-            const closingBrackets = closingBracket.getOpeningBrackets();
-            for (const bracket of closingBrackets) {
-                bracketIds = bracketIds.add(getId(bracket), identityKeyProvider);
-            }
-            map.set(closingBracket.bracketText, new Token(length, 2 /* TokenKind.ClosingBracket */, getId(closingBrackets[0]), bracketIds, BracketAstNode.create(length, closingBracket, bracketIds)));
-        }
-        return new BracketTokens(map);
-    }
-    constructor(map) {
-        this.map = map;
-        this.hasRegExp = false;
-        this._regExpGlobal = null;
-    }
-    getRegExpStr() {
-        if (this.isEmpty) {
-            return null;
-        }
-        else {
-            const keys = [...this.map.keys()];
-            keys.sort();
-            keys.reverse();
-            return keys.map(k => prepareBracketForRegExp(k)).join('|');
-        }
-    }
-    /**
-     * Returns null if there is no such regexp (because there are no brackets).
-    */
-    get regExpGlobal() {
-        if (!this.hasRegExp) {
-            const regExpStr = this.getRegExpStr();
-            this._regExpGlobal = regExpStr ? new RegExp(regExpStr, 'gi') : null;
-            this.hasRegExp = true;
-        }
-        return this._regExpGlobal;
-    }
-    getToken(value) {
-        return this.map.get(value.toLowerCase());
-    }
-    findClosingTokenText(openingBracketIds) {
-        for (const [closingText, info] of this.map) {
-            if (info.kind === 2 /* TokenKind.ClosingBracket */ && info.bracketIds.intersects(openingBracketIds)) {
-                return closingText;
-            }
-        }
-        return undefined;
-    }
-    get isEmpty() {
-        return this.map.size === 0;
-    }
-}
-function prepareBracketForRegExp(str) {
-    let escaped = escapeRegExpCharacters(str);
-    // These bracket pair delimiters start or end with letters
-    // see https://github.com/microsoft/vscode/issues/132162 https://github.com/microsoft/vscode/issues/150440
-    if (/^[\w ]+/.test(str)) {
-        escaped = `\\b${escaped}`;
-    }
-    if (/[\w ]+$/.test(str)) {
-        escaped = `${escaped}\\b`;
-    }
-    return escaped;
-}
-class LanguageAgnosticBracketTokens {
-    constructor(denseKeyProvider, getLanguageConfiguration) {
-        this.denseKeyProvider = denseKeyProvider;
-        this.getLanguageConfiguration = getLanguageConfiguration;
-        this.languageIdToBracketTokens = new Map();
-    }
-    didLanguageChange(languageId) {
-        // Report a change whenever the language configuration updates.
-        return this.languageIdToBracketTokens.has(languageId);
-    }
-    getSingleLanguageBracketTokens(languageId) {
-        let singleLanguageBracketTokens = this.languageIdToBracketTokens.get(languageId);
-        if (!singleLanguageBracketTokens) {
-            singleLanguageBracketTokens = BracketTokens.createFromLanguage(this.getLanguageConfiguration(languageId), this.denseKeyProvider);
-            this.languageIdToBracketTokens.set(languageId, singleLanguageBracketTokens);
-        }
-        return singleLanguageBracketTokens;
-    }
-}
-
-export { BracketTokens, LanguageAgnosticBracketTokens };

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

@@ -1,59 +0,0 @@
-import { toUint8 } from '../../../base/common/uint.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * A fast character classifier that uses a compact array for ASCII values.
- */
-class CharacterClassifier {
-    constructor(_defaultValue) {
-        const defaultValue = toUint8(_defaultValue);
-        this._defaultValue = defaultValue;
-        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
-        this._map = new Map();
-    }
-    static _createAsciiMap(defaultValue) {
-        const asciiMap = new Uint8Array(256);
-        asciiMap.fill(defaultValue);
-        return asciiMap;
-    }
-    set(charCode, _value) {
-        const value = toUint8(_value);
-        if (charCode >= 0 && charCode < 256) {
-            this._asciiMap[charCode] = value;
-        }
-        else {
-            this._map.set(charCode, value);
-        }
-    }
-    get(charCode) {
-        if (charCode >= 0 && charCode < 256) {
-            return this._asciiMap[charCode];
-        }
-        else {
-            return (this._map.get(charCode) || this._defaultValue);
-        }
-    }
-    clear() {
-        this._asciiMap.fill(this._defaultValue);
-        this._map.clear();
-    }
-}
-class CharacterSet {
-    constructor() {
-        this._actual = new CharacterClassifier(0 /* Boolean.False */);
-    }
-    add(charCode) {
-        this._actual.set(charCode, 1 /* Boolean.True */);
-    }
-    has(charCode) {
-        return (this._actual.get(charCode) === 1 /* Boolean.True */);
-    }
-    clear() {
-        return this._actual.clear();
-    }
-}
-
-export { CharacterClassifier, CharacterSet };

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

@@ -1,40 +0,0 @@
-import { StandardAutoClosingPairConditional } from '../languageConfiguration.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class CharacterPairSupport {
-    static { this.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES = ';:.,=}])> \n\t'; }
-    static { this.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS = '\'"`;:.,=}])> \n\t'; }
-    constructor(config) {
-        if (config.autoClosingPairs) {
-            this._autoClosingPairs = config.autoClosingPairs.map(el => new StandardAutoClosingPairConditional(el));
-        }
-        else if (config.brackets) {
-            this._autoClosingPairs = config.brackets.map(b => new StandardAutoClosingPairConditional({ open: b[0], close: b[1] }));
-        }
-        else {
-            this._autoClosingPairs = [];
-        }
-        if (config.__electricCharacterSupport && config.__electricCharacterSupport.docComment) {
-            const docComment = config.__electricCharacterSupport.docComment;
-            // IDocComment is legacy, only partially supported
-            this._autoClosingPairs.push(new StandardAutoClosingPairConditional({ open: docComment.open, close: docComment.close || '' }));
-        }
-        this._autoCloseBeforeForQuotes = typeof config.autoCloseBefore === 'string' ? config.autoCloseBefore : CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES;
-        this._autoCloseBeforeForBrackets = typeof config.autoCloseBefore === 'string' ? config.autoCloseBefore : CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS;
-        this._surroundingPairs = config.surroundingPairs || this._autoClosingPairs;
-    }
-    getAutoClosingPairs() {
-        return this._autoClosingPairs;
-    }
-    getAutoCloseBeforeSet(forQuotes) {
-        return (forQuotes ? this._autoCloseBeforeForQuotes : this._autoCloseBeforeForBrackets);
-    }
-    getSurroundingPairs() {
-        return this._surroundingPairs;
-    }
-}
-
-export { CharacterPairSupport };

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

@@ -1,97 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { Range } from '../../core/range.js';
-import { editorBracketHighlightingUnexpectedBracketForeground, editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6 } from '../../core/editorColorRegistry.js';
-import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ColorizedBracketPairsDecorationProvider extends Disposable {
-    constructor(textModel) {
-        super();
-        this.textModel = textModel;
-        this.colorProvider = new ColorProvider();
-        this.onDidChangeEmitter = new Emitter();
-        this.onDidChange = this.onDidChangeEmitter.event;
-        this.colorizationOptions = textModel.getOptions().bracketPairColorizationOptions;
-        this._register(textModel.bracketPairs.onDidChange(e => {
-            this.onDidChangeEmitter.fire();
-        }));
-    }
-    //#region TextModel events
-    handleDidChangeOptions(e) {
-        this.colorizationOptions = this.textModel.getOptions().bracketPairColorizationOptions;
-    }
-    //#endregion
-    getDecorationsInRange(range, ownerId, filterOutValidation, onlyMinimapDecorations) {
-        if (onlyMinimapDecorations) {
-            // Bracket pair colorization decorations are not rendered in the minimap
-            return [];
-        }
-        if (ownerId === undefined) {
-            return [];
-        }
-        if (!this.colorizationOptions.enabled) {
-            return [];
-        }
-        const result = this.textModel.bracketPairs.getBracketsInRange(range, true).map(bracket => ({
-            id: `bracket${bracket.range.toString()}-${bracket.nestingLevel}`,
-            options: {
-                description: 'BracketPairColorization',
-                inlineClassName: this.colorProvider.getInlineClassName(bracket, this.colorizationOptions.independentColorPoolPerBracketType),
-            },
-            ownerId: 0,
-            range: bracket.range,
-        })).toArray();
-        return result;
-    }
-    getAllDecorations(ownerId, filterOutValidation) {
-        if (ownerId === undefined) {
-            return [];
-        }
-        if (!this.colorizationOptions.enabled) {
-            return [];
-        }
-        return this.getDecorationsInRange(new Range(1, 1, this.textModel.getLineCount(), 1), ownerId, filterOutValidation);
-    }
-}
-class ColorProvider {
-    constructor() {
-        this.unexpectedClosingBracketClassName = 'unexpected-closing-bracket';
-    }
-    getInlineClassName(bracket, independentColorPoolPerBracketType) {
-        if (bracket.isInvalid) {
-            return this.unexpectedClosingBracketClassName;
-        }
-        return this.getInlineClassNameOfLevel(independentColorPoolPerBracketType ? bracket.nestingLevelOfEqualBracketType : bracket.nestingLevel);
-    }
-    getInlineClassNameOfLevel(level) {
-        // To support a dynamic amount of colors up to 6 colors,
-        // we use a number that is a lcm of all numbers from 1 to 6.
-        return `bracket-highlighting-${level % 30}`;
-    }
-}
-registerThemingParticipant((theme, collector) => {
-    const colors = [
-        editorBracketHighlightingForeground1,
-        editorBracketHighlightingForeground2,
-        editorBracketHighlightingForeground3,
-        editorBracketHighlightingForeground4,
-        editorBracketHighlightingForeground5,
-        editorBracketHighlightingForeground6
-    ];
-    const colorProvider = new ColorProvider();
-    collector.addRule(`.monaco-editor .${colorProvider.unexpectedClosingBracketClassName} { color: ${theme.getColor(editorBracketHighlightingUnexpectedBracketForeground)}; }`);
-    const colorValues = colors
-        .map(c => theme.getColor(c))
-        .filter((c) => !!c)
-        .filter(c => !c.isTransparent());
-    for (let level = 0; level < 30; level++) {
-        const color = colorValues[level % colorValues.length];
-        collector.addRule(`.monaco-editor .${colorProvider.getInlineClassNameOfLevel(level)} { color: ${color}; }`);
-    }
-});
-
-export { ColorizedBracketPairsDecorationProvider };