monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,343 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,97 @@
+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 };