monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/defaultLinesDiffComputer.js

@@ -0,0 +1,188 @@
+import { equals } from '../../../../base/common/arrays.js';
+import { assertFn } from '../../../../base/common/assert.js';
+import { LineRange } from '../../core/ranges/lineRange.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
+import { Range } from '../../core/range.js';
+import { ArrayText } from '../../core/text/abstractText.js';
+import { LinesDiff, MovedText } from '../linesDiffComputer.js';
+import { DetailedLineRangeMapping, RangeMapping, lineRangeMappingFromRangeMappings, LineRangeMapping } from '../rangeMapping.js';
+import { InfiniteTimeout, DateTimeout, SequenceDiff } from './algorithms/diffAlgorithm.js';
+import { DynamicProgrammingDiffing } from './algorithms/dynamicProgrammingDiffing.js';
+import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';
+import { computeMovedLines } from './computeMovedLines.js';
+import { optimizeSequenceDiffs, removeVeryShortMatchingLinesBetweenDiffs, extendDiffsToEntireWordIfAppropriate, removeShortMatches, removeVeryShortMatchingTextBetweenLongDiffs } from './heuristicSequenceOptimizations.js';
+import { LineSequence } from './lineSequence.js';
+import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class DefaultLinesDiffComputer {
+    constructor() {
+        this.dynamicProgrammingDiffing = new DynamicProgrammingDiffing();
+        this.myersDiffingAlgorithm = new MyersDiffAlgorithm();
+    }
+    computeDiff(originalLines, modifiedLines, options) {
+        if (originalLines.length <= 1 && equals(originalLines, modifiedLines, (a, b) => a === b)) {
+            return new LinesDiff([], [], false);
+        }
+        if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {
+            return new LinesDiff([
+                new DetailedLineRangeMapping(new LineRange(1, originalLines.length + 1), new LineRange(1, modifiedLines.length + 1), [
+                    new RangeMapping(new Range(1, 1, originalLines.length, originalLines[originalLines.length - 1].length + 1), new Range(1, 1, modifiedLines.length, modifiedLines[modifiedLines.length - 1].length + 1))
+                ])
+            ], [], false);
+        }
+        const timeout = options.maxComputationTimeMs === 0 ? InfiniteTimeout.instance : new DateTimeout(options.maxComputationTimeMs);
+        const considerWhitespaceChanges = !options.ignoreTrimWhitespace;
+        const perfectHashes = new Map();
+        function getOrCreateHash(text) {
+            let hash = perfectHashes.get(text);
+            if (hash === undefined) {
+                hash = perfectHashes.size;
+                perfectHashes.set(text, hash);
+            }
+            return hash;
+        }
+        const originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim()));
+        const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim()));
+        const sequence1 = new LineSequence(originalLinesHashes, originalLines);
+        const sequence2 = new LineSequence(modifiedLinesHashes, modifiedLines);
+        const lineAlignmentResult = (() => {
+            if (sequence1.length + sequence2.length < 1700) {
+                // Use the improved algorithm for small files
+                return this.dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2]
+                    ? modifiedLines[offset2].length === 0
+                        ? 0.1
+                        : 1 + Math.log(1 + modifiedLines[offset2].length)
+                    : 0.99);
+            }
+            return this.myersDiffingAlgorithm.compute(sequence1, sequence2, timeout);
+        })();
+        let lineAlignments = lineAlignmentResult.diffs;
+        let hitTimeout = lineAlignmentResult.hitTimeout;
+        lineAlignments = optimizeSequenceDiffs(sequence1, sequence2, lineAlignments);
+        lineAlignments = removeVeryShortMatchingLinesBetweenDiffs(sequence1, sequence2, lineAlignments);
+        const alignments = [];
+        const scanForWhitespaceChanges = (equalLinesCount) => {
+            if (!considerWhitespaceChanges) {
+                return;
+            }
+            for (let i = 0; i < equalLinesCount; i++) {
+                const seq1Offset = seq1LastStart + i;
+                const seq2Offset = seq2LastStart + i;
+                if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {
+                    // This is because of whitespace changes, diff these lines
+                    const characterDiffs = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(new OffsetRange(seq1Offset, seq1Offset + 1), new OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges, options);
+                    for (const a of characterDiffs.mappings) {
+                        alignments.push(a);
+                    }
+                    if (characterDiffs.hitTimeout) {
+                        hitTimeout = true;
+                    }
+                }
+            }
+        };
+        let seq1LastStart = 0;
+        let seq2LastStart = 0;
+        for (const diff of lineAlignments) {
+            assertFn(() => diff.seq1Range.start - seq1LastStart === diff.seq2Range.start - seq2LastStart);
+            const equalLinesCount = diff.seq1Range.start - seq1LastStart;
+            scanForWhitespaceChanges(equalLinesCount);
+            seq1LastStart = diff.seq1Range.endExclusive;
+            seq2LastStart = diff.seq2Range.endExclusive;
+            const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options);
+            if (characterDiffs.hitTimeout) {
+                hitTimeout = true;
+            }
+            for (const a of characterDiffs.mappings) {
+                alignments.push(a);
+            }
+        }
+        scanForWhitespaceChanges(originalLines.length - seq1LastStart);
+        const original = new ArrayText(originalLines);
+        const modified = new ArrayText(modifiedLines);
+        const changes = lineRangeMappingFromRangeMappings(alignments, original, modified);
+        let moves = [];
+        if (options.computeMoves) {
+            moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges, options);
+        }
+        // Make sure all ranges are valid
+        assertFn(() => {
+            function validatePosition(pos, lines) {
+                if (pos.lineNumber < 1 || pos.lineNumber > lines.length) {
+                    return false;
+                }
+                const line = lines[pos.lineNumber - 1];
+                if (pos.column < 1 || pos.column > line.length + 1) {
+                    return false;
+                }
+                return true;
+            }
+            function validateRange(range, lines) {
+                if (range.startLineNumber < 1 || range.startLineNumber > lines.length + 1) {
+                    return false;
+                }
+                if (range.endLineNumberExclusive < 1 || range.endLineNumberExclusive > lines.length + 1) {
+                    return false;
+                }
+                return true;
+            }
+            for (const c of changes) {
+                if (!c.innerChanges) {
+                    return false;
+                }
+                for (const ic of c.innerChanges) {
+                    const valid = validatePosition(ic.modifiedRange.getStartPosition(), modifiedLines) && validatePosition(ic.modifiedRange.getEndPosition(), modifiedLines) &&
+                        validatePosition(ic.originalRange.getStartPosition(), originalLines) && validatePosition(ic.originalRange.getEndPosition(), originalLines);
+                    if (!valid) {
+                        return false;
+                    }
+                }
+                if (!validateRange(c.modified, modifiedLines) || !validateRange(c.original, originalLines)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        return new LinesDiff(changes, moves, hitTimeout);
+    }
+    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges, options) {
+        const moves = computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout);
+        const movesWithDiffs = moves.map(m => {
+            const moveChanges = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges, options);
+            const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, new ArrayText(originalLines), new ArrayText(modifiedLines), true);
+            return new MovedText(m, mappings);
+        });
+        return movesWithDiffs;
+    }
+    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options) {
+        const lineRangeMapping = toLineRangeMapping(diff);
+        const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
+        const slice1 = new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges);
+        const slice2 = new LinesSliceCharSequence(modifiedLines, rangeMapping.modifiedRange, considerWhitespaceChanges);
+        const diffResult = slice1.length + slice2.length < 500
+            ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)
+            : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
+        let diffs = diffResult.diffs;
+        diffs = optimizeSequenceDiffs(slice1, slice2, diffs);
+        diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findWordContaining(idx));
+        if (options.extendToSubwords) {
+            diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findSubWordContaining(idx), true);
+        }
+        diffs = removeShortMatches(slice1, slice2, diffs);
+        diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);
+        const result = diffs.map((d) => new RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));
+        // Assert: result applied on original should be the same as diff applied to original
+        return {
+            mappings: result,
+            hitTimeout: diffResult.hitTimeout,
+        };
+    }
+}
+function toLineRangeMapping(sequenceDiff) {
+    return new LineRangeMapping(new LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1), new LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1));
+}
+
+export { DefaultLinesDiffComputer };

package/dist/workers/defaultProviders.js

@@ -0,0 +1,230 @@
+import { coalesce } from '../../../../base/common/arrays.js';
+import { UriList } from '../../../../base/common/dataTransfer.js';
+import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Mimes } from '../../../../base/common/mime.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { relativePath } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localize } from '../../../../nls.js';
+import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
+import { DocumentPasteTriggerKind } from '../../../common/languages.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.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 SimplePasteAndDropProvider {
+    constructor(kind) {
+        this.copyMimeTypes = [];
+        this.kind = kind;
+        this.providedDropEditKinds = [this.kind];
+        this.providedPasteEditKinds = [this.kind];
+    }
+    async provideDocumentPasteEdits(_model, _ranges, dataTransfer, context, token) {
+        const edit = await this.getEdit(dataTransfer, token);
+        if (!edit) {
+            return undefined;
+        }
+        return {
+            edits: [{ insertText: edit.insertText, title: edit.title, kind: edit.kind, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo }],
+            dispose() { },
+        };
+    }
+    async provideDocumentDropEdits(_model, _position, dataTransfer, token) {
+        const edit = await this.getEdit(dataTransfer, token);
+        if (!edit) {
+            return;
+        }
+        return {
+            edits: [{ insertText: edit.insertText, title: edit.title, kind: edit.kind, handledMimeType: edit.handledMimeType, yieldTo: edit.yieldTo }],
+            dispose() { },
+        };
+    }
+}
+class DefaultTextPasteOrDropEditProvider extends SimplePasteAndDropProvider {
+    static { this.id = 'text'; }
+    constructor() {
+        super(HierarchicalKind.Empty.append('text', 'plain'));
+        this.id = DefaultTextPasteOrDropEditProvider.id;
+        this.dropMimeTypes = [Mimes.text];
+        this.pasteMimeTypes = [Mimes.text];
+    }
+    async getEdit(dataTransfer, _token) {
+        const textEntry = dataTransfer.get(Mimes.text);
+        if (!textEntry) {
+            return;
+        }
+        // Suppress if there's also a uriList entry.
+        // Typically the uri-list contains the same text as the text entry so showing both is confusing.
+        if (dataTransfer.has(Mimes.uriList)) {
+            return;
+        }
+        const insertText = await textEntry.asString();
+        return {
+            handledMimeType: Mimes.text,
+            title: localize(926, "Insert Plain Text"),
+            insertText,
+            kind: this.kind,
+        };
+    }
+}
+class PathProvider extends SimplePasteAndDropProvider {
+    constructor() {
+        super(HierarchicalKind.Empty.append('uri', 'path', 'absolute'));
+        this.dropMimeTypes = [Mimes.uriList];
+        this.pasteMimeTypes = [Mimes.uriList];
+    }
+    async getEdit(dataTransfer, token) {
+        const entries = await extractUriList(dataTransfer);
+        if (!entries.length || token.isCancellationRequested) {
+            return;
+        }
+        let uriCount = 0;
+        const insertText = entries
+            .map(({ uri, originalText }) => {
+            if (uri.scheme === Schemas.file) {
+                return uri.fsPath;
+            }
+            else {
+                uriCount++;
+                return originalText;
+            }
+        })
+            .join(' ');
+        let label;
+        if (uriCount > 0) {
+            // Dropping at least one generic uri (such as https) so use most generic label
+            label = entries.length > 1
+                ? localize(927, "Insert Uris")
+                : localize(928, "Insert Uri");
+        }
+        else {
+            // All the paths are file paths
+            label = entries.length > 1
+                ? localize(929, "Insert Paths")
+                : localize(930, "Insert Path");
+        }
+        return {
+            handledMimeType: Mimes.uriList,
+            insertText,
+            title: label,
+            kind: this.kind,
+        };
+    }
+}
+let RelativePathProvider = class RelativePathProvider extends SimplePasteAndDropProvider {
+    constructor(_workspaceContextService) {
+        super(HierarchicalKind.Empty.append('uri', 'path', 'relative'));
+        this._workspaceContextService = _workspaceContextService;
+        this.dropMimeTypes = [Mimes.uriList];
+        this.pasteMimeTypes = [Mimes.uriList];
+    }
+    async getEdit(dataTransfer, token) {
+        const entries = await extractUriList(dataTransfer);
+        if (!entries.length || token.isCancellationRequested) {
+            return;
+        }
+        const relativeUris = coalesce(entries.map(({ uri }) => {
+            const root = this._workspaceContextService.getWorkspaceFolder(uri);
+            return root ? relativePath(root.uri, uri) : undefined;
+        }));
+        if (!relativeUris.length) {
+            return;
+        }
+        return {
+            handledMimeType: Mimes.uriList,
+            insertText: relativeUris.join(' '),
+            title: entries.length > 1
+                ? localize(931, "Insert Relative Paths")
+                : localize(932, "Insert Relative Path"),
+            kind: this.kind,
+        };
+    }
+};
+RelativePathProvider = __decorate([
+    __param(0, IWorkspaceContextService)
+], RelativePathProvider);
+class PasteHtmlProvider {
+    constructor() {
+        this.kind = new HierarchicalKind('html');
+        this.providedPasteEditKinds = [this.kind];
+        this.copyMimeTypes = [];
+        this.pasteMimeTypes = ['text/html'];
+        this._yieldTo = [{ mimeType: Mimes.text }];
+    }
+    async provideDocumentPasteEdits(_model, _ranges, dataTransfer, context, token) {
+        if (context.triggerKind !== DocumentPasteTriggerKind.PasteAs && !context.only?.contains(this.kind)) {
+            return;
+        }
+        const entry = dataTransfer.get('text/html');
+        const htmlText = await entry?.asString();
+        if (!htmlText || token.isCancellationRequested) {
+            return;
+        }
+        return {
+            dispose() { },
+            edits: [{
+                    insertText: htmlText,
+                    yieldTo: this._yieldTo,
+                    title: localize(933, 'Insert HTML'),
+                    kind: this.kind,
+                }],
+        };
+    }
+}
+async function extractUriList(dataTransfer) {
+    const urlListEntry = dataTransfer.get(Mimes.uriList);
+    if (!urlListEntry) {
+        return [];
+    }
+    const strUriList = await urlListEntry.asString();
+    const entries = [];
+    for (const entry of UriList.parse(strUriList)) {
+        try {
+            entries.push({ uri: URI.parse(entry), originalText: entry });
+        }
+        catch {
+            // noop
+        }
+    }
+    return entries;
+}
+const genericLanguageSelector = { scheme: '*', hasAccessToAllModels: true };
+let DefaultDropProvidersFeature = class DefaultDropProvidersFeature extends Disposable {
+    constructor(languageFeaturesService, workspaceContextService) {
+        super();
+        this._register(languageFeaturesService.documentDropEditProvider.register(genericLanguageSelector, new DefaultTextPasteOrDropEditProvider()));
+        this._register(languageFeaturesService.documentDropEditProvider.register(genericLanguageSelector, new PathProvider()));
+        this._register(languageFeaturesService.documentDropEditProvider.register(genericLanguageSelector, new RelativePathProvider(workspaceContextService)));
+    }
+};
+DefaultDropProvidersFeature = __decorate([
+    __param(0, ILanguageFeaturesService),
+    __param(1, IWorkspaceContextService)
+], DefaultDropProvidersFeature);
+let DefaultPasteProvidersFeature = class DefaultPasteProvidersFeature extends Disposable {
+    constructor(languageFeaturesService, workspaceContextService) {
+        super();
+        this._register(languageFeaturesService.documentPasteEditProvider.register(genericLanguageSelector, new DefaultTextPasteOrDropEditProvider()));
+        this._register(languageFeaturesService.documentPasteEditProvider.register(genericLanguageSelector, new PathProvider()));
+        this._register(languageFeaturesService.documentPasteEditProvider.register(genericLanguageSelector, new RelativePathProvider(workspaceContextService)));
+        this._register(languageFeaturesService.documentPasteEditProvider.register(genericLanguageSelector, new PasteHtmlProvider()));
+    }
+};
+DefaultPasteProvidersFeature = __decorate([
+    __param(0, ILanguageFeaturesService),
+    __param(1, IWorkspaceContextService)
+], DefaultPasteProvidersFeature);
+
+export { DefaultDropProvidersFeature, DefaultPasteProvidersFeature, DefaultTextPasteOrDropEditProvider };

package/dist/workers/defaultStyles.js

@@ -0,0 +1,194 @@
+import { asCssVariable, asCssVariableWithDefault } from '../common/colorUtils.js';
+import { activeContrastBorder, textLinkForeground, contrastBorder, focusBorder } from '../common/colors/baseColors.js';
+import '../common/colors/chartsColors.js';
+import { widgetShadow, problemsInfoIconForeground, problemsWarningIconForeground, problemsErrorIconForeground, widgetBorder, editorWidgetForeground, editorWidgetBackground, breadcrumbsActiveSelectionForeground, breadcrumbsFocusForeground, breadcrumbsForeground, breadcrumbsBackground, editorWidgetBorder } from '../common/colors/editorColors.js';
+import { keybindingLabelBottomBorder, keybindingLabelBorder, keybindingLabelForeground, keybindingLabelBackground, buttonBorder, buttonSecondaryHoverBackground, buttonSecondaryBackground, buttonSecondaryForeground, buttonHoverBackground, buttonBackground, buttonSeparator, buttonForeground, inputActiveOptionBackground, inputActiveOptionForeground, inputActiveOptionBorder, radioInactiveHoverBackground, radioInactiveBorder, radioInactiveBackground, radioInactiveForeground, radioActiveBorder, radioActiveBackground, radioActiveForeground, checkboxDisabledForeground, checkboxDisabledBackground, checkboxForeground, checkboxBorder, checkboxBackground, inputValidationErrorForeground, inputValidationErrorBackground, inputValidationErrorBorder, inputValidationWarningForeground, inputValidationWarningBackground, inputValidationWarningBorder, inputValidationInfoForeground, inputValidationInfoBackground, inputValidationInfoBorder, inputBorder, inputForeground, inputBackground, selectBorder, selectForeground, selectListBackground, selectBackground } from '../common/colors/inputColors.js';
+import { listFilterWidgetShadow, listFilterWidgetNoMatchesOutline, listFilterWidgetOutline, listFilterWidgetBackground, tableOddRowsBackgroundColor, tableColumnsBorder, treeInactiveIndentGuidesStroke, treeIndentGuidesStroke, listDropBetweenBackground, listDropOverBackground, listHoverForeground, listHoverBackground, listInactiveFocusOutline, listInactiveFocusBackground, listInactiveSelectionForeground, listInactiveSelectionIconForeground, listInactiveSelectionBackground, listActiveSelectionForeground, listActiveSelectionBackground, listFocusAndSelectionOutline, listActiveSelectionIconForeground, listFocusOutline, listFocusForeground, listFocusBackground } from '../common/colors/listColors.js';
+import { menuSeparatorBackground, menuSelectionBorder, menuSelectionBackground, menuSelectionForeground, menuBackground, menuForeground, menuBorder } from '../common/colors/menuColors.js';
+import '../common/colors/minimapColors.js';
+import { progressBarBackground, badgeForeground, badgeBackground, scrollbarShadow, scrollbarSliderActiveBackground, scrollbarSliderHoverBackground, scrollbarSliderBackground } from '../common/colors/miscColors.js';
+import { quickInputListFocusForeground, quickInputListFocusIconForeground, quickInputListFocusBackground, pickerGroupForeground } from '../common/colors/quickpickColors.js';
+import '../common/colors/searchColors.js';
+import { Color } from '../../../base/common/color.js';
+
+function overrideStyles(override, styles) {
+    const result = { ...styles };
+    for (const key in override) {
+        const val = override[key];
+        result[key] = val !== undefined ? asCssVariable(val) : undefined;
+    }
+    return result;
+}
+const defaultKeybindingLabelStyles = {
+    keybindingLabelBackground: asCssVariable(keybindingLabelBackground),
+    keybindingLabelForeground: asCssVariable(keybindingLabelForeground),
+    keybindingLabelBorder: asCssVariable(keybindingLabelBorder),
+    keybindingLabelBottomBorder: asCssVariable(keybindingLabelBottomBorder),
+    keybindingLabelShadow: asCssVariable(widgetShadow)
+};
+const defaultButtonStyles = {
+    buttonForeground: asCssVariable(buttonForeground),
+    buttonSeparator: asCssVariable(buttonSeparator),
+    buttonBackground: asCssVariable(buttonBackground),
+    buttonHoverBackground: asCssVariable(buttonHoverBackground),
+    buttonSecondaryForeground: asCssVariable(buttonSecondaryForeground),
+    buttonSecondaryBackground: asCssVariable(buttonSecondaryBackground),
+    buttonSecondaryHoverBackground: asCssVariable(buttonSecondaryHoverBackground),
+    buttonBorder: asCssVariable(buttonBorder),
+};
+const defaultProgressBarStyles = {
+    progressBarBackground: asCssVariable(progressBarBackground)
+};
+const defaultToggleStyles = {
+    inputActiveOptionBorder: asCssVariable(inputActiveOptionBorder),
+    inputActiveOptionForeground: asCssVariable(inputActiveOptionForeground),
+    inputActiveOptionBackground: asCssVariable(inputActiveOptionBackground)
+};
+({
+    activeForeground: asCssVariable(radioActiveForeground),
+    activeBackground: asCssVariable(radioActiveBackground),
+    activeBorder: asCssVariable(radioActiveBorder),
+    inactiveForeground: asCssVariable(radioInactiveForeground),
+    inactiveBackground: asCssVariable(radioInactiveBackground),
+    inactiveBorder: asCssVariable(radioInactiveBorder),
+    inactiveHoverBackground: asCssVariable(radioInactiveHoverBackground),
+});
+const defaultCheckboxStyles = {
+    checkboxBackground: asCssVariable(checkboxBackground),
+    checkboxBorder: asCssVariable(checkboxBorder),
+    checkboxForeground: asCssVariable(checkboxForeground),
+    checkboxDisabledBackground: asCssVariable(checkboxDisabledBackground),
+    checkboxDisabledForeground: asCssVariable(checkboxDisabledForeground),
+};
+({
+    dialogBackground: asCssVariable(editorWidgetBackground),
+    dialogForeground: asCssVariable(editorWidgetForeground),
+    dialogShadow: asCssVariable(widgetShadow),
+    dialogBorder: asCssVariable(widgetBorder),
+    errorIconForeground: asCssVariable(problemsErrorIconForeground),
+    warningIconForeground: asCssVariable(problemsWarningIconForeground),
+    infoIconForeground: asCssVariable(problemsInfoIconForeground),
+    textLinkForeground: asCssVariable(textLinkForeground)
+});
+const defaultInputBoxStyles = {
+    inputBackground: asCssVariable(inputBackground),
+    inputForeground: asCssVariable(inputForeground),
+    inputBorder: asCssVariable(inputBorder),
+    inputValidationInfoBorder: asCssVariable(inputValidationInfoBorder),
+    inputValidationInfoBackground: asCssVariable(inputValidationInfoBackground),
+    inputValidationInfoForeground: asCssVariable(inputValidationInfoForeground),
+    inputValidationWarningBorder: asCssVariable(inputValidationWarningBorder),
+    inputValidationWarningBackground: asCssVariable(inputValidationWarningBackground),
+    inputValidationWarningForeground: asCssVariable(inputValidationWarningForeground),
+    inputValidationErrorBorder: asCssVariable(inputValidationErrorBorder),
+    inputValidationErrorBackground: asCssVariable(inputValidationErrorBackground),
+    inputValidationErrorForeground: asCssVariable(inputValidationErrorForeground)
+};
+const defaultFindWidgetStyles = {
+    listFilterWidgetBackground: asCssVariable(listFilterWidgetBackground),
+    listFilterWidgetOutline: asCssVariable(listFilterWidgetOutline),
+    listFilterWidgetNoMatchesOutline: asCssVariable(listFilterWidgetNoMatchesOutline),
+    listFilterWidgetShadow: asCssVariable(listFilterWidgetShadow),
+    inputBoxStyles: defaultInputBoxStyles,
+    toggleStyles: defaultToggleStyles
+};
+const defaultCountBadgeStyles = {
+    badgeBackground: asCssVariable(badgeBackground),
+    badgeForeground: asCssVariable(badgeForeground),
+    badgeBorder: asCssVariable(contrastBorder)
+};
+({
+    breadcrumbsBackground: asCssVariable(breadcrumbsBackground),
+    breadcrumbsForeground: asCssVariable(breadcrumbsForeground),
+    breadcrumbsHoverForeground: asCssVariable(breadcrumbsFocusForeground),
+    breadcrumbsFocusForeground: asCssVariable(breadcrumbsFocusForeground),
+    breadcrumbsFocusAndSelectionForeground: asCssVariable(breadcrumbsActiveSelectionForeground)
+});
+const defaultListStyles = {
+    listBackground: undefined,
+    listInactiveFocusForeground: undefined,
+    listFocusBackground: asCssVariable(listFocusBackground),
+    listFocusForeground: asCssVariable(listFocusForeground),
+    listFocusOutline: asCssVariable(listFocusOutline),
+    listActiveSelectionBackground: asCssVariable(listActiveSelectionBackground),
+    listActiveSelectionForeground: asCssVariable(listActiveSelectionForeground),
+    listActiveSelectionIconForeground: asCssVariable(listActiveSelectionIconForeground),
+    listFocusAndSelectionOutline: asCssVariable(listFocusAndSelectionOutline),
+    listFocusAndSelectionBackground: asCssVariable(listActiveSelectionBackground),
+    listFocusAndSelectionForeground: asCssVariable(listActiveSelectionForeground),
+    listInactiveSelectionBackground: asCssVariable(listInactiveSelectionBackground),
+    listInactiveSelectionIconForeground: asCssVariable(listInactiveSelectionIconForeground),
+    listInactiveSelectionForeground: asCssVariable(listInactiveSelectionForeground),
+    listInactiveFocusBackground: asCssVariable(listInactiveFocusBackground),
+    listInactiveFocusOutline: asCssVariable(listInactiveFocusOutline),
+    listHoverBackground: asCssVariable(listHoverBackground),
+    listHoverForeground: asCssVariable(listHoverForeground),
+    listDropOverBackground: asCssVariable(listDropOverBackground),
+    listDropBetweenBackground: asCssVariable(listDropBetweenBackground),
+    listSelectionOutline: asCssVariable(activeContrastBorder),
+    listHoverOutline: asCssVariable(activeContrastBorder),
+    treeIndentGuidesStroke: asCssVariable(treeIndentGuidesStroke),
+    treeInactiveIndentGuidesStroke: asCssVariable(treeInactiveIndentGuidesStroke),
+    treeStickyScrollBackground: undefined,
+    treeStickyScrollBorder: undefined,
+    treeStickyScrollShadow: asCssVariable(scrollbarShadow),
+    tableColumnsBorder: asCssVariable(tableColumnsBorder),
+    tableOddRowsBackgroundColor: asCssVariable(tableOddRowsBackgroundColor),
+};
+function getListStyles(override) {
+    return overrideStyles(override, defaultListStyles);
+}
+const defaultSelectBoxStyles = {
+    selectBackground: asCssVariable(selectBackground),
+    selectListBackground: asCssVariable(selectListBackground),
+    selectForeground: asCssVariable(selectForeground),
+    decoratorRightForeground: asCssVariable(pickerGroupForeground),
+    selectBorder: asCssVariable(selectBorder),
+    focusBorder: asCssVariable(focusBorder),
+    listFocusBackground: asCssVariable(quickInputListFocusBackground),
+    listInactiveSelectionIconForeground: asCssVariable(quickInputListFocusIconForeground),
+    listFocusForeground: asCssVariable(quickInputListFocusForeground),
+    listFocusOutline: asCssVariableWithDefault(activeContrastBorder, Color.transparent.toString()),
+    listHoverBackground: asCssVariable(listHoverBackground),
+    listHoverForeground: asCssVariable(listHoverForeground),
+    listHoverOutline: asCssVariable(activeContrastBorder),
+    selectListBorder: asCssVariable(editorWidgetBorder),
+    listBackground: undefined,
+    listActiveSelectionBackground: undefined,
+    listActiveSelectionForeground: undefined,
+    listActiveSelectionIconForeground: undefined,
+    listFocusAndSelectionBackground: undefined,
+    listDropOverBackground: undefined,
+    listDropBetweenBackground: undefined,
+    listInactiveSelectionBackground: undefined,
+    listInactiveSelectionForeground: undefined,
+    listInactiveFocusBackground: undefined,
+    listInactiveFocusOutline: undefined,
+    listSelectionOutline: undefined,
+    listFocusAndSelectionForeground: undefined,
+    listFocusAndSelectionOutline: undefined,
+    listInactiveFocusForeground: undefined,
+    tableColumnsBorder: undefined,
+    tableOddRowsBackgroundColor: undefined,
+    treeIndentGuidesStroke: undefined,
+    treeInactiveIndentGuidesStroke: undefined,
+    treeStickyScrollBackground: undefined,
+    treeStickyScrollBorder: undefined,
+    treeStickyScrollShadow: undefined
+};
+const defaultMenuStyles = {
+    shadowColor: asCssVariable(widgetShadow),
+    borderColor: asCssVariable(menuBorder),
+    foregroundColor: asCssVariable(menuForeground),
+    backgroundColor: asCssVariable(menuBackground),
+    selectionForegroundColor: asCssVariable(menuSelectionForeground),
+    selectionBackgroundColor: asCssVariable(menuSelectionBackground),
+    selectionBorderColor: asCssVariable(menuSelectionBorder),
+    separatorColor: asCssVariable(menuSeparatorBackground),
+    scrollbarShadow: asCssVariable(scrollbarShadow),
+    scrollbarSliderBackground: asCssVariable(scrollbarSliderBackground),
+    scrollbarSliderHoverBackground: asCssVariable(scrollbarSliderHoverBackground),
+    scrollbarSliderActiveBackground: asCssVariable(scrollbarSliderActiveBackground)
+};
+
+export { defaultButtonStyles, defaultCheckboxStyles, defaultCountBadgeStyles, defaultFindWidgetStyles, defaultInputBoxStyles, defaultKeybindingLabelStyles, defaultListStyles, defaultMenuStyles, defaultProgressBarStyles, defaultSelectBoxStyles, defaultToggleStyles, getListStyles };