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

package/vscode/src/vs/editor/contrib/codelens/browser/codelensWidget.js

@@ -0,0 +1,250 @@
+import { $, reset } from '../../../../base/browser/dom.js';
+import { renderLabelWithIcons } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import './codelensWidget.css.js';
+import { Range } from '../../../common/core/range.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+class CodeLensViewZone {
+    constructor(afterLineNumber, heightInPx, onHeight) {
+        this.afterColumn = 1073741824 ;
+        this.afterLineNumber = afterLineNumber;
+        this.heightInPx = heightInPx;
+        this._onHeight = onHeight;
+        this.suppressMouseDown = true;
+        this.domNode = document.createElement('div');
+    }
+    onComputedHeight(height) {
+        if (this._lastHeight === undefined) {
+            this._lastHeight = height;
+        }
+        else if (this._lastHeight !== height) {
+            this._lastHeight = height;
+            this._onHeight();
+        }
+    }
+    isVisible() {
+        return this._lastHeight !== 0
+            && this.domNode.hasAttribute('monaco-visible-view-zone');
+    }
+}
+class CodeLensContentWidget {
+    static { this._idPool = 0; }
+    constructor(editor, line) {
+        this.allowEditorOverflow = false;
+        this.suppressMouseDown = true;
+        this._commands = ( new Map());
+        this._isEmpty = true;
+        this._editor = editor;
+        this._id = `codelens.widget-${(CodeLensContentWidget._idPool++)}`;
+        this.updatePosition(line);
+        this._domNode = document.createElement('span');
+        this._domNode.className = `codelens-decoration`;
+    }
+    withCommands(lenses, animate) {
+        this._commands.clear();
+        const children = [];
+        let hasSymbol = false;
+        for (let i = 0; i < lenses.length; i++) {
+            const lens = lenses[i];
+            if (!lens) {
+                continue;
+            }
+            hasSymbol = true;
+            if (lens.command) {
+                const title = renderLabelWithIcons(lens.command.title.trim());
+                if (lens.command.id) {
+                    children.push($('a', { id: String(i), title: lens.command.tooltip, role: 'button' }, ...title));
+                    this._commands.set(String(i), lens.command);
+                }
+                else {
+                    children.push($('span', { title: lens.command.tooltip }, ...title));
+                }
+                if (i + 1 < lenses.length) {
+                    children.push($('span', undefined, '\u00a0|\u00a0'));
+                }
+            }
+        }
+        if (!hasSymbol) {
+            reset(this._domNode, $('span', undefined, 'no commands'));
+        }
+        else {
+            reset(this._domNode, ...children);
+            if (this._isEmpty && animate) {
+                this._domNode.classList.add('fadein');
+            }
+            this._isEmpty = false;
+        }
+    }
+    getCommand(link) {
+        return link.parentElement === this._domNode
+            ? this._commands.get(link.id)
+            : undefined;
+    }
+    getId() {
+        return this._id;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    updatePosition(line) {
+        const column = this._editor.getModel().getLineFirstNonWhitespaceColumn(line);
+        this._widgetPosition = {
+            position: { lineNumber: line, column: column },
+            preference: [1 ]
+        };
+    }
+    getPosition() {
+        return this._widgetPosition || null;
+    }
+}
+class CodeLensHelper {
+    constructor() {
+        this._removeDecorations = [];
+        this._addDecorations = [];
+        this._addDecorationsCallbacks = [];
+    }
+    addDecoration(decoration, callback) {
+        this._addDecorations.push(decoration);
+        this._addDecorationsCallbacks.push(callback);
+    }
+    removeDecoration(decorationId) {
+        this._removeDecorations.push(decorationId);
+    }
+    commit(changeAccessor) {
+        const resultingDecorations = changeAccessor.deltaDecorations(this._removeDecorations, this._addDecorations);
+        for (let i = 0, len = resultingDecorations.length; i < len; i++) {
+            this._addDecorationsCallbacks[i](resultingDecorations[i]);
+        }
+    }
+}
+const codeLensDecorationOptions = ModelDecorationOptions.register({
+    collapseOnReplaceEdit: true,
+    description: 'codelens'
+});
+class CodeLensWidget {
+    constructor(data, editor, helper, viewZoneChangeAccessor, heightInPx, updateCallback) {
+        this._isDisposed = false;
+        this._editor = editor;
+        this._data = data;
+        this._decorationIds = [];
+        let range;
+        const lenses = [];
+        this._data.forEach((codeLensData, i) => {
+            if (codeLensData.symbol.command) {
+                lenses.push(codeLensData.symbol);
+            }
+            helper.addDecoration({
+                range: codeLensData.symbol.range,
+                options: codeLensDecorationOptions
+            }, id => this._decorationIds[i] = id);
+            if (!range) {
+                range = Range.lift(codeLensData.symbol.range);
+            }
+            else {
+                range = Range.plusRange(range, codeLensData.symbol.range);
+            }
+        });
+        this._viewZone = ( new CodeLensViewZone(range.startLineNumber - 1, heightInPx, updateCallback));
+        this._viewZoneId = viewZoneChangeAccessor.addZone(this._viewZone);
+        if (lenses.length > 0) {
+            this._createContentWidgetIfNecessary();
+            this._contentWidget.withCommands(lenses, false);
+        }
+    }
+    _createContentWidgetIfNecessary() {
+        if (!this._contentWidget) {
+            this._contentWidget = ( new CodeLensContentWidget(this._editor, this._viewZone.afterLineNumber + 1));
+            this._editor.addContentWidget(this._contentWidget);
+        }
+        else {
+            this._editor.layoutContentWidget(this._contentWidget);
+        }
+    }
+    dispose(helper, viewZoneChangeAccessor) {
+        this._decorationIds.forEach(helper.removeDecoration, helper);
+        this._decorationIds = [];
+        viewZoneChangeAccessor?.removeZone(this._viewZoneId);
+        if (this._contentWidget) {
+            this._editor.removeContentWidget(this._contentWidget);
+            this._contentWidget = undefined;
+        }
+        this._isDisposed = true;
+    }
+    isDisposed() {
+        return this._isDisposed;
+    }
+    isValid() {
+        return ( this._decorationIds.some((id, i) => {
+            const range = this._editor.getModel().getDecorationRange(id);
+            const symbol = this._data[i].symbol;
+            return !!(range && Range.isEmpty(symbol.range) === range.isEmpty());
+        }));
+    }
+    updateCodeLensSymbols(data, helper) {
+        this._decorationIds.forEach(helper.removeDecoration, helper);
+        this._decorationIds = [];
+        this._data = data;
+        this._data.forEach((codeLensData, i) => {
+            helper.addDecoration({
+                range: codeLensData.symbol.range,
+                options: codeLensDecorationOptions
+            }, id => this._decorationIds[i] = id);
+        });
+    }
+    updateHeight(height, viewZoneChangeAccessor) {
+        this._viewZone.heightInPx = height;
+        viewZoneChangeAccessor.layoutZone(this._viewZoneId);
+        if (this._contentWidget) {
+            this._editor.layoutContentWidget(this._contentWidget);
+        }
+    }
+    computeIfNecessary(model) {
+        if (!this._viewZone.isVisible()) {
+            return null;
+        }
+        for (let i = 0; i < this._decorationIds.length; i++) {
+            const range = model.getDecorationRange(this._decorationIds[i]);
+            if (range) {
+                this._data[i].symbol.range = range;
+            }
+        }
+        return this._data;
+    }
+    updateCommands(symbols) {
+        this._createContentWidgetIfNecessary();
+        this._contentWidget.withCommands(symbols, true);
+        for (let i = 0; i < this._data.length; i++) {
+            const resolved = symbols[i];
+            if (resolved) {
+                const { symbol } = this._data[i];
+                symbol.command = resolved.command || symbol.command;
+            }
+        }
+    }
+    getCommand(link) {
+        return this._contentWidget?.getCommand(link);
+    }
+    getLineNumber() {
+        const range = this._editor.getModel().getDecorationRange(this._decorationIds[0]);
+        if (range) {
+            return range.startLineNumber;
+        }
+        return -1;
+    }
+    update(viewZoneChangeAccessor) {
+        if (this.isValid()) {
+            const range = this._editor.getModel().getDecorationRange(this._decorationIds[0]);
+            if (range) {
+                this._viewZone.afterLineNumber = range.startLineNumber - 1;
+                viewZoneChangeAccessor.layoutZone(this._viewZoneId);
+                if (this._contentWidget) {
+                    this._contentWidget.updatePosition(range.startLineNumber);
+                    this._editor.layoutContentWidget(this._contentWidget);
+                }
+            }
+        }
+    }
+    getItems() {
+        return this._data;
+    }
+}
+export { CodeLensHelper, CodeLensWidget };

package/vscode/src/vs/editor/contrib/colorPicker/browser/color.js

@@ -0,0 +1,109 @@
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { illegalArgument, onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Range } from '../../../common/core/range.js';
+import { IModelService } from '../../../common/services/model.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { DefaultDocumentColorProvider } from './defaultDocumentColorProvider.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+async function getColors(colorProviderRegistry, model, token, isDefaultColorDecoratorsEnabled = true) {
+    return _findColorData(( new ColorDataCollector()), colorProviderRegistry, model, token, isDefaultColorDecoratorsEnabled);
+}
+function getColorPresentations(model, colorInfo, provider, token) {
+    return Promise.resolve(provider.provideColorPresentations(model, colorInfo, token));
+}
+class ColorDataCollector {
+    constructor() { }
+    async compute(provider, model, token, colors) {
+        const documentColors = await provider.provideDocumentColors(model, token);
+        if (Array.isArray(documentColors)) {
+            for (const colorInfo of documentColors) {
+                colors.push({ colorInfo, provider });
+            }
+        }
+        return Array.isArray(documentColors);
+    }
+}
+class ExtColorDataCollector {
+    constructor() { }
+    async compute(provider, model, token, colors) {
+        const documentColors = await provider.provideDocumentColors(model, token);
+        if (Array.isArray(documentColors)) {
+            for (const colorInfo of documentColors) {
+                colors.push({ range: colorInfo.range, color: [colorInfo.color.red, colorInfo.color.green, colorInfo.color.blue, colorInfo.color.alpha] });
+            }
+        }
+        return Array.isArray(documentColors);
+    }
+}
+class ColorPresentationsCollector {
+    constructor(colorInfo) {
+        this.colorInfo = colorInfo;
+    }
+    async compute(provider, model, _token, colors) {
+        const documentColors = await provider.provideColorPresentations(model, this.colorInfo, CancellationToken.None);
+        if (Array.isArray(documentColors)) {
+            colors.push(...documentColors);
+        }
+        return Array.isArray(documentColors);
+    }
+}
+async function _findColorData(collector, colorProviderRegistry, model, token, isDefaultColorDecoratorsEnabled) {
+    let validDocumentColorProviderFound = false;
+    let defaultProvider;
+    const colorData = [];
+    const documentColorProviders = colorProviderRegistry.ordered(model);
+    for (let i = documentColorProviders.length - 1; i >= 0; i--) {
+        const provider = documentColorProviders[i];
+        if (provider instanceof DefaultDocumentColorProvider) {
+            defaultProvider = provider;
+        }
+        else {
+            try {
+                if (await collector.compute(provider, model, token, colorData)) {
+                    validDocumentColorProviderFound = true;
+                }
+            }
+            catch (e) {
+                onUnexpectedExternalError(e);
+            }
+        }
+    }
+    if (validDocumentColorProviderFound) {
+        return colorData;
+    }
+    if (defaultProvider && isDefaultColorDecoratorsEnabled) {
+        await collector.compute(defaultProvider, model, token, colorData);
+        return colorData;
+    }
+    return [];
+}
+function _setupColorCommand(accessor, resource) {
+    const { colorProvider: colorProviderRegistry } = accessor.get(ILanguageFeaturesService);
+    const model = accessor.get(IModelService).getModel(resource);
+    if (!model) {
+        throw illegalArgument();
+    }
+    const isDefaultColorDecoratorsEnabled = accessor.get(IConfigurationService).getValue('editor.defaultColorDecorators', { resource });
+    return { model, colorProviderRegistry, isDefaultColorDecoratorsEnabled };
+}
+CommandsRegistry.registerCommand('_executeDocumentColorProvider', function (accessor, ...args) {
+    const [resource] = args;
+    if (!(resource instanceof URI)) {
+        throw illegalArgument();
+    }
+    const { model, colorProviderRegistry, isDefaultColorDecoratorsEnabled } = _setupColorCommand(accessor, resource);
+    return _findColorData(( new ExtColorDataCollector()), colorProviderRegistry, model, CancellationToken.None, isDefaultColorDecoratorsEnabled);
+});
+CommandsRegistry.registerCommand('_executeColorPresentationProvider', function (accessor, ...args) {
+    const [color, context] = args;
+    const { uri, range } = context;
+    if (!(uri instanceof URI) || !Array.isArray(color) || color.length !== 4 || !Range.isIRange(range)) {
+        throw illegalArgument();
+    }
+    const { model, colorProviderRegistry, isDefaultColorDecoratorsEnabled } = _setupColorCommand(accessor, uri);
+    const [red, green, blue, alpha] = color;
+    return _findColorData(( new ColorPresentationsCollector({ range: range, color: { red, green, blue, alpha } })), colorProviderRegistry, model, CancellationToken.None, isDefaultColorDecoratorsEnabled);
+});
+export { getColorPresentations, getColors };

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorContributions.js

@@ -0,0 +1,54 @@
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { Range } from '../../../common/core/range.js';
+import { ColorDecorationInjectedTextMarker } from './colorDetector.js';
+import { ColorHoverParticipant } from './colorHoverParticipant.js';
+import { ModesHoverController } from '../../hover/browser/hover.js';
+import { HoverParticipantRegistry } from '../../hover/browser/hoverTypes.js';
+class ColorContribution extends Disposable {
+    static { this.ID = 'editor.contrib.colorContribution'; }
+    static { this.RECOMPUTE_TIME = 1000; }
+    constructor(_editor) {
+        super();
+        this._editor = _editor;
+        this._register(_editor.onMouseDown((e) => this.onMouseDown(e)));
+    }
+    dispose() {
+        super.dispose();
+    }
+    onMouseDown(mouseEvent) {
+        const colorDecoratorsActivatedOn = this._editor.getOption(146 );
+        if (colorDecoratorsActivatedOn !== 'click' && colorDecoratorsActivatedOn !== 'clickAndHover') {
+            return;
+        }
+        const target = mouseEvent.target;
+        if (target.type !== 6 ) {
+            return;
+        }
+        if (!target.detail.injectedText) {
+            return;
+        }
+        if (target.detail.injectedText.options.attachedData !== ColorDecorationInjectedTextMarker) {
+            return;
+        }
+        if (!target.range) {
+            return;
+        }
+        const hoverController = this._editor.getContribution(ModesHoverController.ID);
+        if (!hoverController) {
+            return;
+        }
+        if (!hoverController.isColorPickerVisible) {
+            const range = ( new Range(
+                target.range.startLineNumber,
+                target.range.startColumn + 1,
+                target.range.endLineNumber,
+                target.range.endColumn + 1
+            ));
+            hoverController.showContentHover(range, 1 , 0 , false, true);
+        }
+    }
+}
+registerEditorContribution(ColorContribution.ID, ColorContribution, 2 );
+HoverParticipantRegistry.register(ColorHoverParticipant);
+export { ColorContribution };

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorDetector.js

@@ -0,0 +1,245 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { TimeoutTimer, createCancelablePromise } from '../../../../base/common/async.js';
+import { RGBA } from '../../../../base/common/color.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { StopWatch } from '../../../../base/common/stopwatch.js';
+import { noBreakWhitespace } from '../../../../base/common/strings.js';
+import { DynamicCssRules } from '../../../browser/editorDom.js';
+import { registerEditorContribution } from '../../../browser/editorExtensions.js';
+import { Range } from '../../../common/core/range.js';
+import { ModelDecorationOptions } from '../../../common/model/textModel.js';
+import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { getColors } from './color.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+var ColorDetector_1;
+const ColorDecorationInjectedTextMarker = Object.create({});
+let ColorDetector = class ColorDetector extends Disposable {
+    static { ColorDetector_1 = this; }
+    static { this.ID = 'editor.contrib.colorDetector'; }
+    static { this.RECOMPUTE_TIME = 1000; }
+    constructor(_editor, _configurationService, _languageFeaturesService, languageFeatureDebounceService) {
+        super();
+        this._editor = _editor;
+        this._configurationService = _configurationService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._localToDispose = this._register(( new DisposableStore()));
+        this._decorationsIds = [];
+        this._colorDatas = ( new Map());
+        this._colorDecoratorIds = this._editor.createDecorationsCollection();
+        this._ruleFactory = ( new DynamicCssRules(this._editor));
+        this._decoratorLimitReporter = ( new DecoratorLimitReporter());
+        this._colorDecorationClassRefs = this._register(( new DisposableStore()));
+        this._debounceInformation = languageFeatureDebounceService.for(_languageFeaturesService.colorProvider, 'Document Colors', { min: ColorDetector_1.RECOMPUTE_TIME });
+        this._register(_editor.onDidChangeModel(() => {
+            this._isColorDecoratorsEnabled = this.isEnabled();
+            this.updateColors();
+        }));
+        this._register(_editor.onDidChangeModelLanguage(() => this.updateColors()));
+        this._register(_languageFeaturesService.colorProvider.onDidChange(() => this.updateColors()));
+        this._register(_editor.onDidChangeConfiguration((e) => {
+            const prevIsEnabled = this._isColorDecoratorsEnabled;
+            this._isColorDecoratorsEnabled = this.isEnabled();
+            this._isDefaultColorDecoratorsEnabled = this._editor.getOption(145 );
+            const updatedColorDecoratorsSetting = prevIsEnabled !== this._isColorDecoratorsEnabled || e.hasChanged(21 );
+            const updatedDefaultColorDecoratorsSetting = e.hasChanged(145 );
+            if (updatedColorDecoratorsSetting || updatedDefaultColorDecoratorsSetting) {
+                if (this._isColorDecoratorsEnabled) {
+                    this.updateColors();
+                }
+                else {
+                    this.removeAllDecorations();
+                }
+            }
+        }));
+        this._timeoutTimer = null;
+        this._computePromise = null;
+        this._isColorDecoratorsEnabled = this.isEnabled();
+        this._isDefaultColorDecoratorsEnabled = this._editor.getOption(145 );
+        this.updateColors();
+    }
+    isEnabled() {
+        const model = this._editor.getModel();
+        if (!model) {
+            return false;
+        }
+        const languageId = model.getLanguageId();
+        const deprecatedConfig = this._configurationService.getValue(languageId);
+        if (deprecatedConfig && typeof deprecatedConfig === 'object') {
+            const colorDecorators = deprecatedConfig['colorDecorators'];
+            if (colorDecorators && colorDecorators['enable'] !== undefined && !colorDecorators['enable']) {
+                return colorDecorators['enable'];
+            }
+        }
+        return this._editor.getOption(20 );
+    }
+    get limitReporter() {
+        return this._decoratorLimitReporter;
+    }
+    static get(editor) {
+        return editor.getContribution(this.ID);
+    }
+    dispose() {
+        this.stop();
+        this.removeAllDecorations();
+        super.dispose();
+    }
+    updateColors() {
+        this.stop();
+        if (!this._isColorDecoratorsEnabled) {
+            return;
+        }
+        const model = this._editor.getModel();
+        if (!model || !( this._languageFeaturesService.colorProvider.has(model))) {
+            return;
+        }
+        this._localToDispose.add(this._editor.onDidChangeModelContent(() => {
+            if (!this._timeoutTimer) {
+                this._timeoutTimer = ( new TimeoutTimer());
+                this._timeoutTimer.cancelAndSet(() => {
+                    this._timeoutTimer = null;
+                    this.beginCompute();
+                }, this._debounceInformation.get(model));
+            }
+        }));
+        this.beginCompute();
+    }
+    async beginCompute() {
+        this._computePromise = createCancelablePromise(async (token) => {
+            const model = this._editor.getModel();
+            if (!model) {
+                return [];
+            }
+            const sw = ( new StopWatch(false));
+            const colors = await getColors(this._languageFeaturesService.colorProvider, model, token, this._isDefaultColorDecoratorsEnabled);
+            this._debounceInformation.update(model, sw.elapsed());
+            return colors;
+        });
+        try {
+            const colors = await this._computePromise;
+            this.updateDecorations(colors);
+            this.updateColorDecorators(colors);
+            this._computePromise = null;
+        }
+        catch (e) {
+            onUnexpectedError(e);
+        }
+    }
+    stop() {
+        if (this._timeoutTimer) {
+            this._timeoutTimer.cancel();
+            this._timeoutTimer = null;
+        }
+        if (this._computePromise) {
+            this._computePromise.cancel();
+            this._computePromise = null;
+        }
+        this._localToDispose.clear();
+    }
+    updateDecorations(colorDatas) {
+        const decorations = ( colorDatas.map(c => ({
+            range: {
+                startLineNumber: c.colorInfo.range.startLineNumber,
+                startColumn: c.colorInfo.range.startColumn,
+                endLineNumber: c.colorInfo.range.endLineNumber,
+                endColumn: c.colorInfo.range.endColumn
+            },
+            options: ModelDecorationOptions.EMPTY
+        })));
+        this._editor.changeDecorations((changeAccessor) => {
+            this._decorationsIds = changeAccessor.deltaDecorations(this._decorationsIds, decorations);
+            this._colorDatas = ( new Map());
+            this._decorationsIds.forEach((id, i) => this._colorDatas.set(id, colorDatas[i]));
+        });
+    }
+    updateColorDecorators(colorData) {
+        this._colorDecorationClassRefs.clear();
+        const decorations = [];
+        const limit = this._editor.getOption(21 );
+        for (let i = 0; i < colorData.length && decorations.length < limit; i++) {
+            const { red, green, blue, alpha } = colorData[i].colorInfo.color;
+            const rgba = ( new RGBA(
+                Math.round(red * 255),
+                Math.round(green * 255),
+                Math.round(blue * 255),
+                alpha
+            ));
+            const color = `rgba(${rgba.r}, ${rgba.g}, ${rgba.b}, ${rgba.a})`;
+            const ref = this._colorDecorationClassRefs.add(this._ruleFactory.createClassNameRef({
+                backgroundColor: color
+            }));
+            decorations.push({
+                range: {
+                    startLineNumber: colorData[i].colorInfo.range.startLineNumber,
+                    startColumn: colorData[i].colorInfo.range.startColumn,
+                    endLineNumber: colorData[i].colorInfo.range.endLineNumber,
+                    endColumn: colorData[i].colorInfo.range.endColumn
+                },
+                options: {
+                    description: 'colorDetector',
+                    before: {
+                        content: noBreakWhitespace,
+                        inlineClassName: `${ref.className} colorpicker-color-decoration`,
+                        inlineClassNameAffectsLetterSpacing: true,
+                        attachedData: ColorDecorationInjectedTextMarker
+                    }
+                }
+            });
+        }
+        const limited = limit < colorData.length ? limit : false;
+        this._decoratorLimitReporter.update(colorData.length, limited);
+        this._colorDecoratorIds.set(decorations);
+    }
+    removeAllDecorations() {
+        this._editor.removeDecorations(this._decorationsIds);
+        this._decorationsIds = [];
+        this._colorDecoratorIds.clear();
+        this._colorDecorationClassRefs.clear();
+    }
+    getColorData(position) {
+        const model = this._editor.getModel();
+        if (!model) {
+            return null;
+        }
+        const decorations = model
+            .getDecorationsInRange(Range.fromPositions(position, position))
+            .filter(d => ( this._colorDatas.has(d.id)));
+        if (decorations.length === 0) {
+            return null;
+        }
+        return this._colorDatas.get(decorations[0].id);
+    }
+    isColorDecoration(decoration) {
+        return ( this._colorDecoratorIds.has(decoration));
+    }
+};
+ColorDetector = ColorDetector_1 = ( __decorate([
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ILanguageFeaturesService)),
+    ( __param(3, ILanguageFeatureDebounceService))
+], ColorDetector));
+class DecoratorLimitReporter {
+    constructor() {
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._computed = 0;
+        this._limited = false;
+    }
+    get computed() {
+        return this._computed;
+    }
+    get limited() {
+        return this._limited;
+    }
+    update(computed, limited) {
+        if (computed !== this._computed || limited !== this._limited) {
+            this._computed = computed;
+            this._limited = limited;
+            this._onDidChange.fire();
+        }
+    }
+}
+registerEditorContribution(ColorDetector.ID, ColorDetector, 1 );
+export { ColorDecorationInjectedTextMarker, ColorDetector, DecoratorLimitReporter };