LeonMMcoset/leonpan-pc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

awa

Browse Source
This commit is contained in:
Leonmmcoset
2025-11-02 19:17:20 +08:00
parent ebf784146e
commit e71b69db5f
2575 changed files with 1242294 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
_internal/editor/esm/vs/platform/theme/browser/defaultStyles.js Normal file
View File

@@ -0,0 +1,182 @@
import { keybindingLabelBackground, keybindingLabelBorder, keybindingLabelBottomBorder, keybindingLabelForeground, asCssVariable, widgetShadow, buttonForeground, buttonSeparator, buttonBackground, buttonHoverBackground, buttonSecondaryForeground, buttonSecondaryBackground, buttonSecondaryHoverBackground, buttonBorder, progressBarBackground, inputActiveOptionBorder, inputActiveOptionForeground, inputActiveOptionBackground, editorWidgetBackground, editorWidgetForeground, contrastBorder, checkboxBorder, checkboxBackground, checkboxForeground, problemsErrorIconForeground, problemsWarningIconForeground, problemsInfoIconForeground, inputBackground, inputForeground, inputBorder, textLinkForeground, inputValidationInfoBorder, inputValidationInfoBackground, inputValidationInfoForeground, inputValidationWarningBorder, inputValidationWarningBackground, inputValidationWarningForeground, inputValidationErrorBorder, inputValidationErrorBackground, inputValidationErrorForeground, listFilterWidgetBackground, listFilterWidgetNoMatchesOutline, listFilterWidgetOutline, listFilterWidgetShadow, badgeBackground, badgeForeground, breadcrumbsBackground, breadcrumbsForeground, breadcrumbsFocusForeground, breadcrumbsActiveSelectionForeground, activeContrastBorder, listActiveSelectionBackground, listActiveSelectionForeground, listActiveSelectionIconForeground, listDropOverBackground, listFocusAndSelectionOutline, listFocusBackground, listFocusForeground, listFocusOutline, listHoverBackground, listHoverForeground, listInactiveFocusBackground, listInactiveFocusOutline, listInactiveSelectionBackground, listInactiveSelectionForeground, listInactiveSelectionIconForeground, tableColumnsBorder, tableOddRowsBackgroundColor, treeIndentGuidesStroke, asCssVariableWithDefault, editorWidgetBorder, focusBorder, pickerGroupForeground, quickInputListFocusBackground, quickInputListFocusForeground, quickInputListFocusIconForeground, selectBackground, selectBorder, selectForeground, selectListBackground, treeInactiveIndentGuidesStroke, menuBorder, menuForeground, menuBackground, menuSelectionForeground, menuSelectionBackground, menuSelectionBorder, menuSeparatorBackground, scrollbarShadow, scrollbarSliderActiveBackground, scrollbarSliderBackground, scrollbarSliderHoverBackground, listDropBetweenBackground, radioActiveBackground, radioActiveForeground, radioInactiveBackground, radioInactiveForeground, radioInactiveBorder, radioInactiveHoverBackground, radioActiveBorder, checkboxDisabledBackground, checkboxDisabledForeground, widgetBorder } from '../common/colorRegistry.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;
}
export const defaultKeybindingLabelStyles = {
keybindingLabelBackground: asCssVariable(keybindingLabelBackground),
keybindingLabelForeground: asCssVariable(keybindingLabelForeground),
keybindingLabelBorder: asCssVariable(keybindingLabelBorder),
keybindingLabelBottomBorder: asCssVariable(keybindingLabelBottomBorder),
keybindingLabelShadow: asCssVariable(widgetShadow)
};
export 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),
};
export const defaultProgressBarStyles = {
progressBarBackground: asCssVariable(progressBarBackground)
};
export const defaultToggleStyles = {
inputActiveOptionBorder: asCssVariable(inputActiveOptionBorder),
inputActiveOptionForeground: asCssVariable(inputActiveOptionForeground),
inputActiveOptionBackground: asCssVariable(inputActiveOptionBackground)
};
export const defaultRadioStyles = {
activeForeground: asCssVariable(radioActiveForeground),
activeBackground: asCssVariable(radioActiveBackground),
activeBorder: asCssVariable(radioActiveBorder),
inactiveForeground: asCssVariable(radioInactiveForeground),
inactiveBackground: asCssVariable(radioInactiveBackground),
inactiveBorder: asCssVariable(radioInactiveBorder),
inactiveHoverBackground: asCssVariable(radioInactiveHoverBackground),
};
export const defaultCheckboxStyles = {
checkboxBackground: asCssVariable(checkboxBackground),
checkboxBorder: asCssVariable(checkboxBorder),
checkboxForeground: asCssVariable(checkboxForeground),
checkboxDisabledBackground: asCssVariable(checkboxDisabledBackground),
checkboxDisabledForeground: asCssVariable(checkboxDisabledForeground),
};
export const defaultDialogStyles = {
dialogBackground: asCssVariable(editorWidgetBackground),
dialogForeground: asCssVariable(editorWidgetForeground),
dialogShadow: asCssVariable(widgetShadow),
dialogBorder: asCssVariable(widgetBorder),
errorIconForeground: asCssVariable(problemsErrorIconForeground),
warningIconForeground: asCssVariable(problemsWarningIconForeground),
infoIconForeground: asCssVariable(problemsInfoIconForeground),
textLinkForeground: asCssVariable(textLinkForeground)
};
export 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)
};
export const defaultFindWidgetStyles = {
listFilterWidgetBackground: asCssVariable(listFilterWidgetBackground),
listFilterWidgetOutline: asCssVariable(listFilterWidgetOutline),
listFilterWidgetNoMatchesOutline: asCssVariable(listFilterWidgetNoMatchesOutline),
listFilterWidgetShadow: asCssVariable(listFilterWidgetShadow),
inputBoxStyles: defaultInputBoxStyles,
toggleStyles: defaultToggleStyles
};
export const defaultCountBadgeStyles = {
badgeBackground: asCssVariable(badgeBackground),
badgeForeground: asCssVariable(badgeForeground),
badgeBorder: asCssVariable(contrastBorder)
};
export const defaultBreadcrumbsWidgetStyles = {
breadcrumbsBackground: asCssVariable(breadcrumbsBackground),
breadcrumbsForeground: asCssVariable(breadcrumbsForeground),
breadcrumbsHoverForeground: asCssVariable(breadcrumbsFocusForeground),
breadcrumbsFocusForeground: asCssVariable(breadcrumbsFocusForeground),
breadcrumbsFocusAndSelectionForeground: asCssVariable(breadcrumbsActiveSelectionForeground)
};
export 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),
};
export function getListStyles(override) {
return overrideStyles(override, defaultListStyles);
}
export 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
};
export 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)
};
//# sourceMappingURL=defaultStyles.js.map

1
_internal/editor/esm/vs/platform/theme/browser/defaultStyles.js.map Normal file
View File

File diff suppressed because one or more lines are too long

73
_internal/editor/esm/vs/platform/theme/browser/iconsStyleSheet.js Normal file
View File

@@ -0,0 +1,73 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as css from '../../../base/browser/cssValue.js';
import { Emitter } from '../../../base/common/event.js';
import { DisposableStore } from '../../../base/common/lifecycle.js';
import { ThemeIcon } from '../../../base/common/themables.js';
import { getIconRegistry } from '../common/iconRegistry.js';
export function getIconsStyleSheet(themeService) {
const disposable = new DisposableStore();
const onDidChangeEmmiter = disposable.add(new Emitter());
const iconRegistry = getIconRegistry();
disposable.add(iconRegistry.onDidChange(() => onDidChangeEmmiter.fire()));
if (themeService) {
disposable.add(themeService.onDidProductIconThemeChange(() => onDidChangeEmmiter.fire()));
}
return {
dispose: () => disposable.dispose(),
onDidChange: onDidChangeEmmiter.event,
getCSS() {
const productIconTheme = themeService ? themeService.getProductIconTheme() : new UnthemedProductIconTheme();
const usedFontIds = {};
const rules = new css.Builder();
const rootAttribs = new css.Builder();
for (const contribution of iconRegistry.getIcons()) {
const definition = productIconTheme.getIcon(contribution);
if (!definition) {
continue;
}
const fontContribution = definition.font;
const fontFamilyVar = css.inline `--vscode-icon-${css.className(contribution.id)}-font-family`;
const contentVar = css.inline `--vscode-icon-${css.className(contribution.id)}-content`;
if (fontContribution) {
usedFontIds[fontContribution.id] = fontContribution.definition;
rootAttribs.push(css.inline `${fontFamilyVar}: ${css.stringValue(fontContribution.id)};`, css.inline `${contentVar}: ${css.stringValue(definition.fontCharacter)};`);
rules.push(css.inline `.codicon-${css.className(contribution.id)}:before { content: ${css.stringValue(definition.fontCharacter)}; font-family: ${css.stringValue(fontContribution.id)}; }`);
}
else {
rootAttribs.push(css.inline `${contentVar}: ${css.stringValue(definition.fontCharacter)}; ${fontFamilyVar}: 'codicon';`);
rules.push(css.inline `.codicon-${css.className(contribution.id)}:before { content: ${css.stringValue(definition.fontCharacter)}; }`);
}
}
for (const id in usedFontIds) {
const definition = usedFontIds[id];
const fontWeight = definition.weight ? css.inline `font-weight: ${css.identValue(definition.weight)};` : css.inline ``;
const fontStyle = definition.style ? css.inline `font-style: ${css.identValue(definition.style)};` : css.inline ``;
const src = new css.Builder();
for (const l of definition.src) {
src.push(css.inline `${css.asCSSUrl(l.location)} format(${css.stringValue(l.format)})`);
}
rules.push(css.inline `@font-face { src: ${src.join(', ')}; font-family: ${css.stringValue(id)};${fontWeight}${fontStyle} font-display: block; }`);
}
rules.push(css.inline `:root { ${rootAttribs.join(' ')} }`);
return rules.join('\n');
}
};
}
export class UnthemedProductIconTheme {
getIcon(contribution) {
const iconRegistry = getIconRegistry();
let definition = contribution.defaults;
while (ThemeIcon.isThemeIcon(definition)) {
const c = iconRegistry.getIcon(definition.id);
if (!c) {
return undefined;
}
definition = c.defaults;
}
return definition;
}
}
//# sourceMappingURL=iconsStyleSheet.js.map

1
_internal/editor/esm/vs/platform/theme/browser/iconsStyleSheet.js.map Normal file
View File

File diff suppressed because one or more lines are too long

17
_internal/editor/esm/vs/platform/theme/common/colorRegistry.js Normal file
View File

@@ -0,0 +1,17 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
export * from './colorUtils.js';
// Make sure all color files are exported
export * from './colors/baseColors.js';
export * from './colors/chartsColors.js';
export * from './colors/editorColors.js';
export * from './colors/inputColors.js';
export * from './colors/listColors.js';
export * from './colors/menuColors.js';
export * from './colors/minimapColors.js';
export * from './colors/miscColors.js';
export * from './colors/quickpickColors.js';
export * from './colors/searchColors.js';
//# sourceMappingURL=colorRegistry.js.map

1
_internal/editor/esm/vs/platform/theme/common/colorRegistry.js.map Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src/vs/platform/theme/common/colorRegistry.ts","vs/platform/theme/common/colorRegistry.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,cAAc,iBAAiB,CAAC;AAEhC,yCAAyC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC","file":"colorRegistry.js","sourceRoot":"file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nexport * from './colorUtils.js';\n\n// Make sure all color files are exported\nexport * from './colors/baseColors.js';\nexport * from './colors/chartsColors.js';\nexport * from './colors/editorColors.js';\nexport * from './colors/inputColors.js';\nexport * from './colors/listColors.js';\nexport * from './colors/menuColors.js';\nexport * from './colors/minimapColors.js';\nexport * from './colors/miscColors.js';\nexport * from './colors/quickpickColors.js';\nexport * from './colors/searchColors.js';\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nexport * from './colorUtils.js';\n\n// Make sure all color files are exported\nexport * from './colors/baseColors.js';\nexport * from './colors/chartsColors.js';\nexport * from './colors/editorColors.js';\nexport * from './colors/inputColors.js';\nexport * from './colors/listColors.js';\nexport * from './colors/menuColors.js';\nexport * from './colors/minimapColors.js';\nexport * from './colors/miscColors.js';\nexport * from './colors/quickpickColors.js';\nexport * from './colors/searchColors.js';\n"]}

197
_internal/editor/esm/vs/platform/theme/common/colorUtils.js Normal file
View File

@@ -0,0 +1,197 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { assertNever } from '../../../base/common/assert.js';
import { RunOnceScheduler } from '../../../base/common/async.js';
import { Color } from '../../../base/common/color.js';
import { Emitter } from '../../../base/common/event.js';
import { Extensions as JSONExtensions } from '../../jsonschemas/common/jsonContributionRegistry.js';
import * as platform from '../../registry/common/platform.js';
import * as nls from '../../../nls.js';
import { Disposable } from '../../../base/common/lifecycle.js';
/**
* Returns the css variable name for the given color identifier. Dots (`.`) are replaced with hyphens (`-`) and
* everything is prefixed with `--vscode-`.
*
* @sample `editorSuggestWidget.background` is `--vscode-editorSuggestWidget-background`.
*/
export function asCssVariableName(colorIdent) {
return `--vscode-${colorIdent.replace(/\./g, '-')}`;
}
export function asCssVariable(color) {
return `var(${asCssVariableName(color)})`;
}
export function asCssVariableWithDefault(color, defaultCssValue) {
return `var(${asCssVariableName(color)}, ${defaultCssValue})`;
}
export function isColorDefaults(value) {
return value !== null && typeof value === 'object' && 'light' in value && 'dark' in value;
}
// color registry
export const Extensions = {
ColorContribution: 'base.contributions.colors'
};
export const DEFAULT_COLOR_CONFIG_VALUE = 'default';
class ColorRegistry extends Disposable {
constructor() {
super();
this._onDidChangeSchema = this._register(new Emitter());
this.onDidChangeSchema = this._onDidChangeSchema.event;
this.colorSchema = { type: 'object', properties: {} };
this.colorReferenceSchema = { type: 'string', enum: [], enumDescriptions: [] };
this.colorsById = {};
}
registerColor(id, defaults, description, needsTransparency = false, deprecationMessage) {
const colorContribution = { id, description, defaults, needsTransparency, deprecationMessage };
this.colorsById[id] = colorContribution;
const propertySchema = { type: 'string', format: 'color-hex', defaultSnippets: [{ body: '${1:#ff0000}' }] };
if (deprecationMessage) {
propertySchema.deprecationMessage = deprecationMessage;
}
if (needsTransparency) {
propertySchema.pattern = '^#(?:(?<rgba>[0-9a-fA-f]{3}[0-9a-eA-E])|(?:[0-9a-fA-F]{6}(?:(?![fF]{2})(?:[0-9a-fA-F]{2}))))?$';
propertySchema.patternErrorMessage = nls.localize(2004, 'This color must be transparent or it will obscure content');
}
this.colorSchema.properties[id] = {
description,
oneOf: [
propertySchema,
{ type: 'string', const: DEFAULT_COLOR_CONFIG_VALUE, description: nls.localize(2005, 'Use the default color.') }
]
};
this.colorReferenceSchema.enum.push(id);
this.colorReferenceSchema.enumDescriptions.push(description);
this._onDidChangeSchema.fire();
return id;
}
getColors() {
return Object.keys(this.colorsById).map(id => this.colorsById[id]);
}
resolveDefaultColor(id, theme) {
const colorDesc = this.colorsById[id];
if (colorDesc?.defaults) {
const colorValue = isColorDefaults(colorDesc.defaults) ? colorDesc.defaults[theme.type] : colorDesc.defaults;
return resolveColorValue(colorValue, theme);
}
return undefined;
}
getColorSchema() {
return this.colorSchema;
}
toString() {
const sorter = (a, b) => {
const cat1 = a.indexOf('.') === -1 ? 0 : 1;
const cat2 = b.indexOf('.') === -1 ? 0 : 1;
if (cat1 !== cat2) {
return cat1 - cat2;
}
return a.localeCompare(b);
};
return Object.keys(this.colorsById).sort(sorter).map(k => `- \`${k}\`: ${this.colorsById[k].description}`).join('\n');
}
}
const colorRegistry = new ColorRegistry();
platform.Registry.add(Extensions.ColorContribution, colorRegistry);
export function registerColor(id, defaults, description, needsTransparency, deprecationMessage) {
return colorRegistry.registerColor(id, defaults, description, needsTransparency, deprecationMessage);
}
// ----- color functions
export function executeTransform(transform, theme) {
switch (transform.op) {
case 0 /* ColorTransformType.Darken */:
return resolveColorValue(transform.value, theme)?.darken(transform.factor);
case 1 /* ColorTransformType.Lighten */:
return resolveColorValue(transform.value, theme)?.lighten(transform.factor);
case 2 /* ColorTransformType.Transparent */:
return resolveColorValue(transform.value, theme)?.transparent(transform.factor);
case 7 /* ColorTransformType.Mix */: {
const primaryColor = resolveColorValue(transform.color, theme) || Color.transparent;
const otherColor = resolveColorValue(transform.with, theme) || Color.transparent;
return primaryColor.mix(otherColor, transform.ratio);
}
case 3 /* ColorTransformType.Opaque */: {
const backgroundColor = resolveColorValue(transform.background, theme);
if (!backgroundColor) {
return resolveColorValue(transform.value, theme);
}
return resolveColorValue(transform.value, theme)?.makeOpaque(backgroundColor);
}
case 4 /* ColorTransformType.OneOf */:
for (const candidate of transform.values) {
const color = resolveColorValue(candidate, theme);
if (color) {
return color;
}
}
return undefined;
case 6 /* ColorTransformType.IfDefinedThenElse */:
return resolveColorValue(theme.defines(transform.if) ? transform.then : transform.else, theme);
case 5 /* ColorTransformType.LessProminent */: {
const from = resolveColorValue(transform.value, theme);
if (!from) {
return undefined;
}
const backgroundColor = resolveColorValue(transform.background, theme);
if (!backgroundColor) {
return from.transparent(transform.factor * transform.transparency);
}
return from.isDarkerThan(backgroundColor)
? Color.getLighterColor(from, backgroundColor, transform.factor).transparent(transform.transparency)
: Color.getDarkerColor(from, backgroundColor, transform.factor).transparent(transform.transparency);
}
default:
throw assertNever(transform);
}
}
export function darken(colorValue, factor) {
return { op: 0 /* ColorTransformType.Darken */, value: colorValue, factor };
}
export function lighten(colorValue, factor) {
return { op: 1 /* ColorTransformType.Lighten */, value: colorValue, factor };
}
export function transparent(colorValue, factor) {
return { op: 2 /* ColorTransformType.Transparent */, value: colorValue, factor };
}
export function oneOf(...colorValues) {
return { op: 4 /* ColorTransformType.OneOf */, values: colorValues };
}
export function ifDefinedThenElse(ifArg, thenArg, elseArg) {
return { op: 6 /* ColorTransformType.IfDefinedThenElse */, if: ifArg, then: thenArg, else: elseArg };
}
export function lessProminent(colorValue, backgroundColorValue, factor, transparency) {
return { op: 5 /* ColorTransformType.LessProminent */, value: colorValue, background: backgroundColorValue, factor, transparency };
}
// ----- implementation
/**
* @param colorValue Resolve a color value in the context of a theme
*/
export function resolveColorValue(colorValue, theme) {
if (colorValue === null) {
return undefined;
}
else if (typeof colorValue === 'string') {
if (colorValue[0] === '#') {
return Color.fromHex(colorValue);
}
return theme.getColor(colorValue);
}
else if (colorValue instanceof Color) {
return colorValue;
}
else if (typeof colorValue === 'object') {
return executeTransform(colorValue, theme);
}
return undefined;
}
export const workbenchColorsSchemaId = 'vscode://schemas/workbench-colors';
const schemaRegistry = platform.Registry.as(JSONExtensions.JSONContribution);
schemaRegistry.registerSchema(workbenchColorsSchemaId, colorRegistry.getColorSchema());
const delayer = new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(workbenchColorsSchemaId), 200);
colorRegistry.onDidChangeSchema(() => {
if (!delayer.isScheduled()) {
delayer.schedule();
}
});
// setTimeout(_ => console.log(colorRegistry.toString()), 5000);
//# sourceMappingURL=colorUtils.js.map

1
_internal/editor/esm/vs/platform/theme/common/colorUtils.js.map Normal file
View File

File diff suppressed because one or more lines are too long

30
_internal/editor/esm/vs/platform/theme/common/colors/baseColors.js Normal file
View File

@@ -0,0 +1,30 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color } from '../../../../base/common/color.js';
import { registerColor, transparent } from '../colorUtils.js';
export const foreground = registerColor('foreground', { dark: '#CCCCCC', light: '#616161', hcDark: '#FFFFFF', hcLight: '#292929' }, nls.localize(1756, "Overall foreground color. This color is only used if not overridden by a component."));
export const disabledForeground = registerColor('disabledForeground', { dark: '#CCCCCC80', light: '#61616180', hcDark: '#A5A5A5', hcLight: '#7F7F7F' }, nls.localize(1757, "Overall foreground for disabled elements. This color is only used if not overridden by a component."));
export const errorForeground = registerColor('errorForeground', { dark: '#F48771', light: '#A1260D', hcDark: '#F48771', hcLight: '#B5200D' }, nls.localize(1758, "Overall foreground color for error messages. This color is only used if not overridden by a component."));
export const descriptionForeground = registerColor('descriptionForeground', { light: '#717171', dark: transparent(foreground, 0.7), hcDark: transparent(foreground, 0.7), hcLight: transparent(foreground, 0.7) }, nls.localize(1759, "Foreground color for description text providing additional information, for example for a label."));
export const iconForeground = registerColor('icon.foreground', { dark: '#C5C5C5', light: '#424242', hcDark: '#FFFFFF', hcLight: '#292929' }, nls.localize(1760, "The default color for icons in the workbench."));
export const focusBorder = registerColor('focusBorder', { dark: '#007FD4', light: '#0090F1', hcDark: '#F38518', hcLight: '#006BBD' }, nls.localize(1761, "Overall border color for focused elements. This color is only used if not overridden by a component."));
export const contrastBorder = registerColor('contrastBorder', { light: null, dark: null, hcDark: '#6FC3DF', hcLight: '#0F4A85' }, nls.localize(1762, "An extra border around elements to separate them from others for greater contrast."));
export const activeContrastBorder = registerColor('contrastActiveBorder', { light: null, dark: null, hcDark: focusBorder, hcLight: focusBorder }, nls.localize(1763, "An extra border around active elements to separate them from others for greater contrast."));
export const selectionBackground = registerColor('selection.background', null, nls.localize(1764, "The background color of text selections in the workbench (e.g. for input fields or text areas). Note that this does not apply to selections within the editor."));
// ------ text link
export const textLinkForeground = registerColor('textLink.foreground', { light: '#006AB1', dark: '#3794FF', hcDark: '#21A6FF', hcLight: '#0F4A85' }, nls.localize(1765, "Foreground color for links in text."));
export const textLinkActiveForeground = registerColor('textLink.activeForeground', { light: '#006AB1', dark: '#3794FF', hcDark: '#21A6FF', hcLight: '#0F4A85' }, nls.localize(1766, "Foreground color for links in text when clicked on and on mouse hover."));
export const textSeparatorForeground = registerColor('textSeparator.foreground', { light: '#0000002e', dark: '#ffffff2e', hcDark: Color.black, hcLight: '#292929' }, nls.localize(1767, "Color for text separators."));
// ------ text preformat
export const textPreformatForeground = registerColor('textPreformat.foreground', { light: '#A31515', dark: '#D7BA7D', hcDark: '#000000', hcLight: '#FFFFFF' }, nls.localize(1768, "Foreground color for preformatted text segments."));
export const textPreformatBackground = registerColor('textPreformat.background', { light: '#0000001A', dark: '#FFFFFF1A', hcDark: '#FFFFFF', hcLight: '#09345f' }, nls.localize(1769, "Background color for preformatted text segments."));
// ------ text block quote
export const textBlockQuoteBackground = registerColor('textBlockQuote.background', { light: '#f2f2f2', dark: '#222222', hcDark: null, hcLight: '#F2F2F2' }, nls.localize(1770, "Background color for block quotes in text."));
export const textBlockQuoteBorder = registerColor('textBlockQuote.border', { light: '#007acc80', dark: '#007acc80', hcDark: Color.white, hcLight: '#292929' }, nls.localize(1771, "Border color for block quotes in text."));
// ------ text code block
export const textCodeBlockBackground = registerColor('textCodeBlock.background', { light: '#dcdcdc66', dark: '#0a0a0a66', hcDark: Color.black, hcLight: '#F2F2F2' }, nls.localize(1772, "Background color for code blocks in text."));
//# sourceMappingURL=baseColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/baseColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

18
_internal/editor/esm/vs/platform/theme/common/colors/chartsColors.js Normal file
View File

@@ -0,0 +1,18 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
import { registerColor, transparent } from '../colorUtils.js';
import { foreground } from './baseColors.js';
import { editorErrorForeground, editorInfoForeground, editorWarningForeground } from './editorColors.js';
import { minimapFindMatch } from './minimapColors.js';
export const chartsForeground = registerColor('charts.foreground', foreground, nls.localize(1773, "The foreground color used in charts."));
export const chartsLines = registerColor('charts.lines', transparent(foreground, .5), nls.localize(1774, "The color used for horizontal lines in charts."));
export const chartsRed = registerColor('charts.red', editorErrorForeground, nls.localize(1775, "The red color used in chart visualizations."));
export const chartsBlue = registerColor('charts.blue', editorInfoForeground, nls.localize(1776, "The blue color used in chart visualizations."));
export const chartsYellow = registerColor('charts.yellow', editorWarningForeground, nls.localize(1777, "The yellow color used in chart visualizations."));
export const chartsOrange = registerColor('charts.orange', minimapFindMatch, nls.localize(1778, "The orange color used in chart visualizations."));
export const chartsGreen = registerColor('charts.green', { dark: '#89D185', light: '#388A34', hcDark: '#89D185', hcLight: '#374e06' }, nls.localize(1779, "The green color used in chart visualizations."));
export const chartsPurple = registerColor('charts.purple', { dark: '#B180D7', light: '#652D90', hcDark: '#B180D7', hcLight: '#652D90' }, nls.localize(1780, "The purple color used in chart visualizations."));
//# sourceMappingURL=chartsColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/chartsColors.js.map Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["vs/platform/theme/common/colors/chartsColors.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AACzG,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,MAAM,CAAC,MAAM,gBAAgB,GAAG,aAAa,CAAC,mBAAmB,EAChE,UAAU,EACV,GAAG,CAAC,QAAQ,CAAC,IAAkB,EAAE,sCAAsC,CAAC,CAAC,CAAC;AAE3E,MAAM,CAAC,MAAM,WAAW,GAAG,aAAa,CAAC,cAAc,EACtD,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,EAC3B,GAAG,CAAC,QAAQ,CAAC,IAAa,EAAE,gDAAgD,CAAC,CAAC,CAAC;AAEhF,MAAM,CAAC,MAAM,SAAS,GAAG,aAAa,CAAC,YAAY,EAClD,qBAAqB,EACrB,GAAG,CAAC,QAAQ,CAAC,IAAW,EAAE,6CAA6C,CAAC,CAAC,CAAC;AAE3E,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CAAC,aAAa,EACpD,oBAAoB,EACpB,GAAG,CAAC,QAAQ,CAAC,IAAY,EAAE,8CAA8C,CAAC,CAAC,CAAC;AAE7E,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC,eAAe,EACxD,uBAAuB,EACvB,GAAG,CAAC,QAAQ,CAAC,IAAc,EAAE,gDAAgD,CAAC,CAAC,CAAC;AAEjF,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC,eAAe,EACxD,gBAAgB,EAChB,GAAG,CAAC,QAAQ,CAAC,IAAc,EAAE,gDAAgD,CAAC,CAAC,CAAC;AAEjF,MAAM,CAAC,MAAM,WAAW,GAAG,aAAa,CAAC,cAAc,EACtD,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,EAC5E,GAAG,CAAC,QAAQ,CAAC,IAAa,EAAE,+CAA+C,CAAC,CAAC,CAAC;AAE/E,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC,eAAe,EACxD,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,EAC5E,GAAG,CAAC,QAAQ,CAAC,IAAc,EAAE,gDAAgD,CAAC,CAAC,CAAC","file":"chartsColors.js","sourceRoot":"file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nimport * as nls from '../../../../nls.js';\nimport { registerColor, transparent } from '../colorUtils.js';\n\nimport { foreground } from './baseColors.js';\nimport { editorErrorForeground, editorInfoForeground, editorWarningForeground } from './editorColors.js';\nimport { minimapFindMatch } from './minimapColors.js';\n\n\nexport const chartsForeground = registerColor('charts.foreground',\n\tforeground,\n\tnls.localize('chartsForeground', \"The foreground color used in charts.\"));\n\nexport const chartsLines = registerColor('charts.lines',\n\ttransparent(foreground, .5),\n\tnls.localize('chartsLines', \"The color used for horizontal lines in charts.\"));\n\nexport const chartsRed = registerColor('charts.red',\n\teditorErrorForeground,\n\tnls.localize('chartsRed', \"The red color used in chart visualizations.\"));\n\nexport const chartsBlue = registerColor('charts.blue',\n\teditorInfoForeground,\n\tnls.localize('chartsBlue', \"The blue color used in chart visualizations.\"));\n\nexport const chartsYellow = registerColor('charts.yellow',\n\teditorWarningForeground,\n\tnls.localize('chartsYellow', \"The yellow color used in chart visualizations.\"));\n\nexport const chartsOrange = registerColor('charts.orange',\n\tminimapFindMatch,\n\tnls.localize('chartsOrange', \"The orange color used in chart visualizations.\"));\n\nexport const chartsGreen = registerColor('charts.green',\n\t{ dark: '#89D185', light: '#388A34', hcDark: '#89D185', hcLight: '#374e06' },\n\tnls.localize('chartsGreen', \"The green color used in chart visualizations.\"));\n\nexport const chartsPurple = registerColor('charts.purple',\n\t{ dark: '#B180D7', light: '#652D90', hcDark: '#B180D7', hcLight: '#652D90' },\n\tnls.localize('chartsPurple', \"The purple color used in chart visualizations.\"));\n"]}

128
_internal/editor/esm/vs/platform/theme/common/colors/editorColors.js Normal file
View File

@@ -0,0 +1,128 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color, RGBA } from '../../../../base/common/color.js';
import { registerColor, transparent, lessProminent, darken, lighten } from '../colorUtils.js';
// Import the colors we need
import { foreground, contrastBorder, activeContrastBorder } from './baseColors.js';
import { scrollbarShadow, badgeBackground } from './miscColors.js';
// ----- editor
export const editorBackground = registerColor('editor.background', { light: '#ffffff', dark: '#1E1E1E', hcDark: Color.black, hcLight: Color.white }, nls.localize(1781, "Editor background color."));
export const editorForeground = registerColor('editor.foreground', { light: '#333333', dark: '#BBBBBB', hcDark: Color.white, hcLight: foreground }, nls.localize(1782, "Editor default foreground color."));
export const editorStickyScrollBackground = registerColor('editorStickyScroll.background', editorBackground, nls.localize(1783, "Background color of sticky scroll in the editor"));
export const editorStickyScrollGutterBackground = registerColor('editorStickyScrollGutter.background', editorBackground, nls.localize(1784, "Background color of the gutter part of sticky scroll in the editor"));
export const editorStickyScrollHoverBackground = registerColor('editorStickyScrollHover.background', { dark: '#2A2D2E', light: '#F0F0F0', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, nls.localize(1785, "Background color of sticky scroll on hover in the editor"));
export const editorStickyScrollBorder = registerColor('editorStickyScroll.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1786, "Border color of sticky scroll in the editor"));
export const editorStickyScrollShadow = registerColor('editorStickyScroll.shadow', scrollbarShadow, nls.localize(1787, " Shadow color of sticky scroll in the editor"));
export const editorWidgetBackground = registerColor('editorWidget.background', { dark: '#252526', light: '#F3F3F3', hcDark: '#0C141F', hcLight: Color.white }, nls.localize(1788, 'Background color of editor widgets, such as find/replace.'));
export const editorWidgetForeground = registerColor('editorWidget.foreground', foreground, nls.localize(1789, 'Foreground color of editor widgets, such as find/replace.'));
export const editorWidgetBorder = registerColor('editorWidget.border', { dark: '#454545', light: '#C8C8C8', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1790, 'Border color of editor widgets. The color is only used if the widget chooses to have a border and if the color is not overridden by a widget.'));
export const editorWidgetResizeBorder = registerColor('editorWidget.resizeBorder', null, nls.localize(1791, "Border color of the resize bar of editor widgets. The color is only used if the widget chooses to have a resize border and if the color is not overridden by a widget."));
export const editorErrorBackground = registerColor('editorError.background', null, nls.localize(1792, 'Background color of error text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorErrorForeground = registerColor('editorError.foreground', { dark: '#F14C4C', light: '#E51400', hcDark: '#F48771', hcLight: '#B5200D' }, nls.localize(1793, 'Foreground color of error squigglies in the editor.'));
export const editorErrorBorder = registerColor('editorError.border', { dark: null, light: null, hcDark: Color.fromHex('#E47777').transparent(0.8), hcLight: '#B5200D' }, nls.localize(1794, 'If set, color of double underlines for errors in the editor.'));
export const editorWarningBackground = registerColor('editorWarning.background', null, nls.localize(1795, 'Background color of warning text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorWarningForeground = registerColor('editorWarning.foreground', { dark: '#CCA700', light: '#BF8803', hcDark: '#FFD370', hcLight: '#895503' }, nls.localize(1796, 'Foreground color of warning squigglies in the editor.'));
export const editorWarningBorder = registerColor('editorWarning.border', { dark: null, light: null, hcDark: Color.fromHex('#FFCC00').transparent(0.8), hcLight: Color.fromHex('#FFCC00').transparent(0.8) }, nls.localize(1797, 'If set, color of double underlines for warnings in the editor.'));
export const editorInfoBackground = registerColor('editorInfo.background', null, nls.localize(1798, 'Background color of info text in the editor. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorInfoForeground = registerColor('editorInfo.foreground', { dark: '#3794FF', light: '#1a85ff', hcDark: '#3794FF', hcLight: '#1a85ff' }, nls.localize(1799, 'Foreground color of info squigglies in the editor.'));
export const editorInfoBorder = registerColor('editorInfo.border', { dark: null, light: null, hcDark: Color.fromHex('#3794FF').transparent(0.8), hcLight: '#292929' }, nls.localize(1800, 'If set, color of double underlines for infos in the editor.'));
export const editorHintForeground = registerColor('editorHint.foreground', { dark: Color.fromHex('#eeeeee').transparent(0.7), light: '#6c6c6c', hcDark: null, hcLight: null }, nls.localize(1801, 'Foreground color of hint squigglies in the editor.'));
export const editorHintBorder = registerColor('editorHint.border', { dark: null, light: null, hcDark: Color.fromHex('#eeeeee').transparent(0.8), hcLight: '#292929' }, nls.localize(1802, 'If set, color of double underlines for hints in the editor.'));
export const editorActiveLinkForeground = registerColor('editorLink.activeForeground', { dark: '#4E94CE', light: Color.blue, hcDark: Color.cyan, hcLight: '#292929' }, nls.localize(1803, 'Color of active links.'));
// ----- editor selection
export const editorSelectionBackground = registerColor('editor.selectionBackground', { light: '#ADD6FF', dark: '#264F78', hcDark: '#f3f518', hcLight: '#0F4A85' }, nls.localize(1804, "Color of the editor selection."));
export const editorSelectionForeground = registerColor('editor.selectionForeground', { light: null, dark: null, hcDark: '#000000', hcLight: Color.white }, nls.localize(1805, "Color of the selected text for high contrast."));
export const editorInactiveSelection = registerColor('editor.inactiveSelectionBackground', { light: transparent(editorSelectionBackground, 0.5), dark: transparent(editorSelectionBackground, 0.5), hcDark: transparent(editorSelectionBackground, 0.7), hcLight: transparent(editorSelectionBackground, 0.5) }, nls.localize(1806, "Color of the selection in an inactive editor. The color must not be opaque so as not to hide underlying decorations."), true);
export const editorSelectionHighlight = registerColor('editor.selectionHighlightBackground', { light: lessProminent(editorSelectionBackground, editorBackground, 0.3, 0.6), dark: lessProminent(editorSelectionBackground, editorBackground, 0.3, 0.6), hcDark: null, hcLight: null }, nls.localize(1807, 'Color for regions with the same content as the selection. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorSelectionHighlightBorder = registerColor('editor.selectionHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1808, "Border color for regions with the same content as the selection."));
export const editorCompositionBorder = registerColor('editor.compositionBorder', { light: '#000000', dark: '#ffffff', hcLight: '#000000', hcDark: '#ffffff' }, nls.localize(1809, "The border color for an IME composition."));
// ----- editor find
export const editorFindMatch = registerColor('editor.findMatchBackground', { light: '#A8AC94', dark: '#515C6A', hcDark: null, hcLight: null }, nls.localize(1810, "Color of the current search match."));
export const editorFindMatchForeground = registerColor('editor.findMatchForeground', null, nls.localize(1811, "Text color of the current search match."));
export const editorFindMatchHighlight = registerColor('editor.findMatchHighlightBackground', { light: '#EA5C0055', dark: '#EA5C0055', hcDark: null, hcLight: null }, nls.localize(1812, "Color of the other search matches. The color must not be opaque so as not to hide underlying decorations."), true);
export const editorFindMatchHighlightForeground = registerColor('editor.findMatchHighlightForeground', null, nls.localize(1813, "Foreground color of the other search matches."), true);
export const editorFindRangeHighlight = registerColor('editor.findRangeHighlightBackground', { dark: '#3a3d4166', light: '#b4b4b44d', hcDark: null, hcLight: null }, nls.localize(1814, "Color of the range limiting the search. The color must not be opaque so as not to hide underlying decorations."), true);
export const editorFindMatchBorder = registerColor('editor.findMatchBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1815, "Border color of the current search match."));
export const editorFindMatchHighlightBorder = registerColor('editor.findMatchHighlightBorder', { light: null, dark: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1816, "Border color of the other search matches."));
export const editorFindRangeHighlightBorder = registerColor('editor.findRangeHighlightBorder', { dark: null, light: null, hcDark: transparent(activeContrastBorder, 0.4), hcLight: transparent(activeContrastBorder, 0.4) }, nls.localize(1817, "Border color of the range limiting the search. The color must not be opaque so as not to hide underlying decorations."), true);
// ----- editor hover
export const editorHoverHighlight = registerColor('editor.hoverHighlightBackground', { light: '#ADD6FF26', dark: '#264f7840', hcDark: '#ADD6FF26', hcLight: null }, nls.localize(1818, 'Highlight below the word for which a hover is shown. The color must not be opaque so as not to hide underlying decorations.'), true);
export const editorHoverBackground = registerColor('editorHoverWidget.background', editorWidgetBackground, nls.localize(1819, 'Background color of the editor hover.'));
export const editorHoverForeground = registerColor('editorHoverWidget.foreground', editorWidgetForeground, nls.localize(1820, 'Foreground color of the editor hover.'));
export const editorHoverBorder = registerColor('editorHoverWidget.border', editorWidgetBorder, nls.localize(1821, 'Border color of the editor hover.'));
export const editorHoverStatusBarBackground = registerColor('editorHoverWidget.statusBarBackground', { dark: lighten(editorHoverBackground, 0.2), light: darken(editorHoverBackground, 0.05), hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, nls.localize(1822, "Background color of the editor hover status bar."));
// ----- editor inlay hint
export const editorInlayHintForeground = registerColor('editorInlayHint.foreground', { dark: '#969696', light: '#969696', hcDark: Color.white, hcLight: Color.black }, nls.localize(1823, 'Foreground color of inline hints'));
export const editorInlayHintBackground = registerColor('editorInlayHint.background', { dark: transparent(badgeBackground, .10), light: transparent(badgeBackground, .10), hcDark: transparent(Color.white, .10), hcLight: transparent(badgeBackground, .10) }, nls.localize(1824, 'Background color of inline hints'));
export const editorInlayHintTypeForeground = registerColor('editorInlayHint.typeForeground', editorInlayHintForeground, nls.localize(1825, 'Foreground color of inline hints for types'));
export const editorInlayHintTypeBackground = registerColor('editorInlayHint.typeBackground', editorInlayHintBackground, nls.localize(1826, 'Background color of inline hints for types'));
export const editorInlayHintParameterForeground = registerColor('editorInlayHint.parameterForeground', editorInlayHintForeground, nls.localize(1827, 'Foreground color of inline hints for parameters'));
export const editorInlayHintParameterBackground = registerColor('editorInlayHint.parameterBackground', editorInlayHintBackground, nls.localize(1828, 'Background color of inline hints for parameters'));
// ----- editor lightbulb
export const editorLightBulbForeground = registerColor('editorLightBulb.foreground', { dark: '#FFCC00', light: '#DDB100', hcDark: '#FFCC00', hcLight: '#007ACC' }, nls.localize(1829, "The color used for the lightbulb actions icon."));
export const editorLightBulbAutoFixForeground = registerColor('editorLightBulbAutoFix.foreground', { dark: '#75BEFF', light: '#007ACC', hcDark: '#75BEFF', hcLight: '#007ACC' }, nls.localize(1830, "The color used for the lightbulb auto fix actions icon."));
export const editorLightBulbAiForeground = registerColor('editorLightBulbAi.foreground', editorLightBulbForeground, nls.localize(1831, "The color used for the lightbulb AI icon."));
// ----- editor snippet
export const snippetTabstopHighlightBackground = registerColor('editor.snippetTabstopHighlightBackground', { dark: new Color(new RGBA(124, 124, 124, 0.3)), light: new Color(new RGBA(10, 50, 100, 0.2)), hcDark: new Color(new RGBA(124, 124, 124, 0.3)), hcLight: new Color(new RGBA(10, 50, 100, 0.2)) }, nls.localize(1832, "Highlight background color of a snippet tabstop."));
export const snippetTabstopHighlightBorder = registerColor('editor.snippetTabstopHighlightBorder', null, nls.localize(1833, "Highlight border color of a snippet tabstop."));
export const snippetFinalTabstopHighlightBackground = registerColor('editor.snippetFinalTabstopHighlightBackground', null, nls.localize(1834, "Highlight background color of the final tabstop of a snippet."));
export const snippetFinalTabstopHighlightBorder = registerColor('editor.snippetFinalTabstopHighlightBorder', { dark: '#525252', light: new Color(new RGBA(10, 50, 100, 0.5)), hcDark: '#525252', hcLight: '#292929' }, nls.localize(1835, "Highlight border color of the final tabstop of a snippet."));
// ----- diff editor
export const defaultInsertColor = new Color(new RGBA(155, 185, 85, .2));
export const defaultRemoveColor = new Color(new RGBA(255, 0, 0, .2));
export const diffInserted = registerColor('diffEditor.insertedTextBackground', { dark: '#9ccc2c33', light: '#9ccc2c40', hcDark: null, hcLight: null }, nls.localize(1836, 'Background color for text that got inserted. The color must not be opaque so as not to hide underlying decorations.'), true);
export const diffRemoved = registerColor('diffEditor.removedTextBackground', { dark: '#ff000033', light: '#ff000033', hcDark: null, hcLight: null }, nls.localize(1837, 'Background color for text that got removed. The color must not be opaque so as not to hide underlying decorations.'), true);
export const diffInsertedLine = registerColor('diffEditor.insertedLineBackground', { dark: defaultInsertColor, light: defaultInsertColor, hcDark: null, hcLight: null }, nls.localize(1838, 'Background color for lines that got inserted. The color must not be opaque so as not to hide underlying decorations.'), true);
export const diffRemovedLine = registerColor('diffEditor.removedLineBackground', { dark: defaultRemoveColor, light: defaultRemoveColor, hcDark: null, hcLight: null }, nls.localize(1839, 'Background color for lines that got removed. The color must not be opaque so as not to hide underlying decorations.'), true);
export const diffInsertedLineGutter = registerColor('diffEditorGutter.insertedLineBackground', null, nls.localize(1840, 'Background color for the margin where lines got inserted.'));
export const diffRemovedLineGutter = registerColor('diffEditorGutter.removedLineBackground', null, nls.localize(1841, 'Background color for the margin where lines got removed.'));
export const diffOverviewRulerInserted = registerColor('diffEditorOverview.insertedForeground', null, nls.localize(1842, 'Diff overview ruler foreground for inserted content.'));
export const diffOverviewRulerRemoved = registerColor('diffEditorOverview.removedForeground', null, nls.localize(1843, 'Diff overview ruler foreground for removed content.'));
export const diffInsertedOutline = registerColor('diffEditor.insertedTextBorder', { dark: null, light: null, hcDark: '#33ff2eff', hcLight: '#374E06' }, nls.localize(1844, 'Outline color for the text that got inserted.'));
export const diffRemovedOutline = registerColor('diffEditor.removedTextBorder', { dark: null, light: null, hcDark: '#FF008F', hcLight: '#AD0707' }, nls.localize(1845, 'Outline color for text that got removed.'));
export const diffBorder = registerColor('diffEditor.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1846, 'Border color between the two text editors.'));
export const diffDiagonalFill = registerColor('diffEditor.diagonalFill', { dark: '#cccccc33', light: '#22222233', hcDark: null, hcLight: null }, nls.localize(1847, "Color of the diff editor's diagonal fill. The diagonal fill is used in side-by-side diff views."));
export const diffUnchangedRegionBackground = registerColor('diffEditor.unchangedRegionBackground', 'sideBar.background', nls.localize(1848, "The background color of unchanged blocks in the diff editor."));
export const diffUnchangedRegionForeground = registerColor('diffEditor.unchangedRegionForeground', 'foreground', nls.localize(1849, "The foreground color of unchanged blocks in the diff editor."));
export const diffUnchangedTextBackground = registerColor('diffEditor.unchangedCodeBackground', { dark: '#74747429', light: '#b8b8b829', hcDark: null, hcLight: null }, nls.localize(1850, "The background color of unchanged code in the diff editor."));
// ----- widget
export const widgetShadow = registerColor('widget.shadow', { dark: transparent(Color.black, .36), light: transparent(Color.black, .16), hcDark: null, hcLight: null }, nls.localize(1851, 'Shadow color of widgets such as find/replace inside the editor.'));
export const widgetBorder = registerColor('widget.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1852, 'Border color of widgets such as find/replace inside the editor.'));
// ----- toolbar
export const toolbarHoverBackground = registerColor('toolbar.hoverBackground', { dark: '#5a5d5e50', light: '#b8b8b850', hcDark: null, hcLight: null }, nls.localize(1853, "Toolbar background when hovering over actions using the mouse"));
export const toolbarHoverOutline = registerColor('toolbar.hoverOutline', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1854, "Toolbar outline when hovering over actions using the mouse"));
export const toolbarActiveBackground = registerColor('toolbar.activeBackground', { dark: lighten(toolbarHoverBackground, 0.1), light: darken(toolbarHoverBackground, 0.1), hcDark: null, hcLight: null }, nls.localize(1855, "Toolbar background when holding the mouse over actions"));
// ----- breadcumbs
export const breadcrumbsForeground = registerColor('breadcrumb.foreground', transparent(foreground, 0.8), nls.localize(1856, "Color of focused breadcrumb items."));
export const breadcrumbsBackground = registerColor('breadcrumb.background', editorBackground, nls.localize(1857, "Background color of breadcrumb items."));
export const breadcrumbsFocusForeground = registerColor('breadcrumb.focusForeground', { light: darken(foreground, 0.2), dark: lighten(foreground, 0.1), hcDark: lighten(foreground, 0.1), hcLight: lighten(foreground, 0.1) }, nls.localize(1858, "Color of focused breadcrumb items."));
export const breadcrumbsActiveSelectionForeground = registerColor('breadcrumb.activeSelectionForeground', { light: darken(foreground, 0.2), dark: lighten(foreground, 0.1), hcDark: lighten(foreground, 0.1), hcLight: lighten(foreground, 0.1) }, nls.localize(1859, "Color of selected breadcrumb items."));
export const breadcrumbsPickerBackground = registerColor('breadcrumbPicker.background', editorWidgetBackground, nls.localize(1860, "Background color of breadcrumb item picker."));
// ----- merge
const headerTransparency = 0.5;
const currentBaseColor = Color.fromHex('#40C8AE').transparent(headerTransparency);
const incomingBaseColor = Color.fromHex('#40A6FF').transparent(headerTransparency);
const commonBaseColor = Color.fromHex('#606060').transparent(0.4);
const contentTransparency = 0.4;
const rulerTransparency = 1;
export const mergeCurrentHeaderBackground = registerColor('merge.currentHeaderBackground', { dark: currentBaseColor, light: currentBaseColor, hcDark: null, hcLight: null }, nls.localize(1861, 'Current header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
export const mergeCurrentContentBackground = registerColor('merge.currentContentBackground', transparent(mergeCurrentHeaderBackground, contentTransparency), nls.localize(1862, 'Current content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
export const mergeIncomingHeaderBackground = registerColor('merge.incomingHeaderBackground', { dark: incomingBaseColor, light: incomingBaseColor, hcDark: null, hcLight: null }, nls.localize(1863, 'Incoming header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
export const mergeIncomingContentBackground = registerColor('merge.incomingContentBackground', transparent(mergeIncomingHeaderBackground, contentTransparency), nls.localize(1864, 'Incoming content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
export const mergeCommonHeaderBackground = registerColor('merge.commonHeaderBackground', { dark: commonBaseColor, light: commonBaseColor, hcDark: null, hcLight: null }, nls.localize(1865, 'Common ancestor header background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
export const mergeCommonContentBackground = registerColor('merge.commonContentBackground', transparent(mergeCommonHeaderBackground, contentTransparency), nls.localize(1866, 'Common ancestor content background in inline merge-conflicts. The color must not be opaque so as not to hide underlying decorations.'), true);
export const mergeBorder = registerColor('merge.border', { dark: null, light: null, hcDark: '#C3DF6F', hcLight: '#007ACC' }, nls.localize(1867, 'Border color on headers and the splitter in inline merge-conflicts.'));
export const overviewRulerCurrentContentForeground = registerColor('editorOverviewRuler.currentContentForeground', { dark: transparent(mergeCurrentHeaderBackground, rulerTransparency), light: transparent(mergeCurrentHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, nls.localize(1868, 'Current overview ruler foreground for inline merge-conflicts.'));
export const overviewRulerIncomingContentForeground = registerColor('editorOverviewRuler.incomingContentForeground', { dark: transparent(mergeIncomingHeaderBackground, rulerTransparency), light: transparent(mergeIncomingHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, nls.localize(1869, 'Incoming overview ruler foreground for inline merge-conflicts.'));
export const overviewRulerCommonContentForeground = registerColor('editorOverviewRuler.commonContentForeground', { dark: transparent(mergeCommonHeaderBackground, rulerTransparency), light: transparent(mergeCommonHeaderBackground, rulerTransparency), hcDark: mergeBorder, hcLight: mergeBorder }, nls.localize(1870, 'Common ancestor overview ruler foreground for inline merge-conflicts.'));
export const overviewRulerFindMatchForeground = registerColor('editorOverviewRuler.findMatchForeground', { dark: '#d186167e', light: '#d186167e', hcDark: '#AB5A00', hcLight: '#AB5A00' }, nls.localize(1871, 'Overview ruler marker color for find matches. The color must not be opaque so as not to hide underlying decorations.'), true);
export const overviewRulerSelectionHighlightForeground = registerColor('editorOverviewRuler.selectionHighlightForeground', '#A0A0A0CC', nls.localize(1872, 'Overview ruler marker color for selection highlights. The color must not be opaque so as not to hide underlying decorations.'), true);
// ----- problems
export const problemsErrorIconForeground = registerColor('problemsErrorIcon.foreground', editorErrorForeground, nls.localize(1873, "The color used for the problems error icon."));
export const problemsWarningIconForeground = registerColor('problemsWarningIcon.foreground', editorWarningForeground, nls.localize(1874, "The color used for the problems warning icon."));
export const problemsInfoIconForeground = registerColor('problemsInfoIcon.foreground', editorInfoForeground, nls.localize(1875, "The color used for the problems info icon."));
//# sourceMappingURL=editorColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/editorColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

66
_internal/editor/esm/vs/platform/theme/common/colors/inputColors.js Normal file
View File

@@ -0,0 +1,66 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color, RGBA } from '../../../../base/common/color.js';
import { registerColor, transparent, lighten, darken } from '../colorUtils.js';
// Import the colors we need
import { foreground, contrastBorder, focusBorder, iconForeground } from './baseColors.js';
import { editorWidgetBackground } from './editorColors.js';
// ----- input
export const inputBackground = registerColor('input.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, nls.localize(1876, "Input box background."));
export const inputForeground = registerColor('input.foreground', foreground, nls.localize(1877, "Input box foreground."));
export const inputBorder = registerColor('input.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1878, "Input box border."));
export const inputActiveOptionBorder = registerColor('inputOption.activeBorder', { dark: '#007ACC', light: '#007ACC', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1879, "Border color of activated options in input fields."));
export const inputActiveOptionHoverBackground = registerColor('inputOption.hoverBackground', { dark: '#5a5d5e80', light: '#b8b8b850', hcDark: null, hcLight: null }, nls.localize(1880, "Background color of activated options in input fields."));
export const inputActiveOptionBackground = registerColor('inputOption.activeBackground', { dark: transparent(focusBorder, 0.4), light: transparent(focusBorder, 0.2), hcDark: Color.transparent, hcLight: Color.transparent }, nls.localize(1881, "Background hover color of options in input fields."));
export const inputActiveOptionForeground = registerColor('inputOption.activeForeground', { dark: Color.white, light: Color.black, hcDark: foreground, hcLight: foreground }, nls.localize(1882, "Foreground color of activated options in input fields."));
export const inputPlaceholderForeground = registerColor('input.placeholderForeground', { light: transparent(foreground, 0.5), dark: transparent(foreground, 0.5), hcDark: transparent(foreground, 0.7), hcLight: transparent(foreground, 0.7) }, nls.localize(1883, "Input box foreground color for placeholder text."));
// ----- input validation
export const inputValidationInfoBackground = registerColor('inputValidation.infoBackground', { dark: '#063B49', light: '#D6ECF2', hcDark: Color.black, hcLight: Color.white }, nls.localize(1884, "Input validation background color for information severity."));
export const inputValidationInfoForeground = registerColor('inputValidation.infoForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, nls.localize(1885, "Input validation foreground color for information severity."));
export const inputValidationInfoBorder = registerColor('inputValidation.infoBorder', { dark: '#007acc', light: '#007acc', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1886, "Input validation border color for information severity."));
export const inputValidationWarningBackground = registerColor('inputValidation.warningBackground', { dark: '#352A05', light: '#F6F5D2', hcDark: Color.black, hcLight: Color.white }, nls.localize(1887, "Input validation background color for warning severity."));
export const inputValidationWarningForeground = registerColor('inputValidation.warningForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, nls.localize(1888, "Input validation foreground color for warning severity."));
export const inputValidationWarningBorder = registerColor('inputValidation.warningBorder', { dark: '#B89500', light: '#B89500', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1889, "Input validation border color for warning severity."));
export const inputValidationErrorBackground = registerColor('inputValidation.errorBackground', { dark: '#5A1D1D', light: '#F2DEDE', hcDark: Color.black, hcLight: Color.white }, nls.localize(1890, "Input validation background color for error severity."));
export const inputValidationErrorForeground = registerColor('inputValidation.errorForeground', { dark: null, light: null, hcDark: null, hcLight: foreground }, nls.localize(1891, "Input validation foreground color for error severity."));
export const inputValidationErrorBorder = registerColor('inputValidation.errorBorder', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1892, "Input validation border color for error severity."));
// ----- select
export const selectBackground = registerColor('dropdown.background', { dark: '#3C3C3C', light: Color.white, hcDark: Color.black, hcLight: Color.white }, nls.localize(1893, "Dropdown background."));
export const selectListBackground = registerColor('dropdown.listBackground', { dark: null, light: null, hcDark: Color.black, hcLight: Color.white }, nls.localize(1894, "Dropdown list background."));
export const selectForeground = registerColor('dropdown.foreground', { dark: '#F0F0F0', light: foreground, hcDark: Color.white, hcLight: foreground }, nls.localize(1895, "Dropdown foreground."));
export const selectBorder = registerColor('dropdown.border', { dark: selectBackground, light: '#CECECE', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1896, "Dropdown border."));
// ------ button
export const buttonForeground = registerColor('button.foreground', Color.white, nls.localize(1897, "Button foreground color."));
export const buttonSeparator = registerColor('button.separator', transparent(buttonForeground, .4), nls.localize(1898, "Button separator color."));
export const buttonBackground = registerColor('button.background', { dark: '#0E639C', light: '#007ACC', hcDark: null, hcLight: '#0F4A85' }, nls.localize(1899, "Button background color."));
export const buttonHoverBackground = registerColor('button.hoverBackground', { dark: lighten(buttonBackground, 0.2), light: darken(buttonBackground, 0.2), hcDark: buttonBackground, hcLight: buttonBackground }, nls.localize(1900, "Button background color when hovering."));
export const buttonBorder = registerColor('button.border', contrastBorder, nls.localize(1901, "Button border color."));
export const buttonSecondaryForeground = registerColor('button.secondaryForeground', { dark: Color.white, light: Color.white, hcDark: Color.white, hcLight: foreground }, nls.localize(1902, "Secondary button foreground color."));
export const buttonSecondaryBackground = registerColor('button.secondaryBackground', { dark: '#3A3D41', light: '#5F6A79', hcDark: null, hcLight: Color.white }, nls.localize(1903, "Secondary button background color."));
export const buttonSecondaryHoverBackground = registerColor('button.secondaryHoverBackground', { dark: lighten(buttonSecondaryBackground, 0.2), light: darken(buttonSecondaryBackground, 0.2), hcDark: null, hcLight: null }, nls.localize(1904, "Secondary button background color when hovering."));
// ------ radio
export const radioActiveForeground = registerColor('radio.activeForeground', inputActiveOptionForeground, nls.localize(1905, "Foreground color of active radio option."));
export const radioActiveBackground = registerColor('radio.activeBackground', inputActiveOptionBackground, nls.localize(1906, "Background color of active radio option."));
export const radioActiveBorder = registerColor('radio.activeBorder', inputActiveOptionBorder, nls.localize(1907, "Border color of the active radio option."));
export const radioInactiveForeground = registerColor('radio.inactiveForeground', null, nls.localize(1908, "Foreground color of inactive radio option."));
export const radioInactiveBackground = registerColor('radio.inactiveBackground', null, nls.localize(1909, "Background color of inactive radio option."));
export const radioInactiveBorder = registerColor('radio.inactiveBorder', { light: transparent(radioActiveForeground, .2), dark: transparent(radioActiveForeground, .2), hcDark: transparent(radioActiveForeground, .4), hcLight: transparent(radioActiveForeground, .2) }, nls.localize(1910, "Border color of the inactive radio option."));
export const radioInactiveHoverBackground = registerColor('radio.inactiveHoverBackground', inputActiveOptionHoverBackground, nls.localize(1911, "Background color of inactive active radio option when hovering."));
// ------ checkbox
export const checkboxBackground = registerColor('checkbox.background', selectBackground, nls.localize(1912, "Background color of checkbox widget."));
export const checkboxSelectBackground = registerColor('checkbox.selectBackground', editorWidgetBackground, nls.localize(1913, "Background color of checkbox widget when the element it's in is selected."));
export const checkboxForeground = registerColor('checkbox.foreground', selectForeground, nls.localize(1914, "Foreground color of checkbox widget."));
export const checkboxBorder = registerColor('checkbox.border', selectBorder, nls.localize(1915, "Border color of checkbox widget."));
export const checkboxSelectBorder = registerColor('checkbox.selectBorder', iconForeground, nls.localize(1916, "Border color of checkbox widget when the element it's in is selected."));
export const checkboxDisabledBackground = registerColor('checkbox.disabled.background', { op: 7 /* ColorTransformType.Mix */, color: checkboxBackground, with: checkboxForeground, ratio: 0.33 }, nls.localize(1917, "Background of a disabled checkbox."));
export const checkboxDisabledForeground = registerColor('checkbox.disabled.foreground', { op: 7 /* ColorTransformType.Mix */, color: checkboxForeground, with: checkboxBackground, ratio: 0.33 }, nls.localize(1918, "Foreground of a disabled checkbox."));
// ------ keybinding label
export const keybindingLabelBackground = registerColor('keybindingLabel.background', { dark: new Color(new RGBA(128, 128, 128, 0.17)), light: new Color(new RGBA(221, 221, 221, 0.4)), hcDark: Color.transparent, hcLight: Color.transparent }, nls.localize(1919, "Keybinding label background color. The keybinding label is used to represent a keyboard shortcut."));
export const keybindingLabelForeground = registerColor('keybindingLabel.foreground', { dark: Color.fromHex('#CCCCCC'), light: Color.fromHex('#555555'), hcDark: Color.white, hcLight: foreground }, nls.localize(1920, "Keybinding label foreground color. The keybinding label is used to represent a keyboard shortcut."));
export const keybindingLabelBorder = registerColor('keybindingLabel.border', { dark: new Color(new RGBA(51, 51, 51, 0.6)), light: new Color(new RGBA(204, 204, 204, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: contrastBorder }, nls.localize(1921, "Keybinding label border color. The keybinding label is used to represent a keyboard shortcut."));
export const keybindingLabelBottomBorder = registerColor('keybindingLabel.bottomBorder', { dark: new Color(new RGBA(68, 68, 68, 0.6)), light: new Color(new RGBA(187, 187, 187, 0.4)), hcDark: new Color(new RGBA(111, 195, 223)), hcLight: foreground }, nls.localize(1922, "Keybinding label border bottom color. The keybinding label is used to represent a keyboard shortcut."));
//# sourceMappingURL=inputColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/inputColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

51
_internal/editor/esm/vs/platform/theme/common/colors/listColors.js Normal file
View File

@@ -0,0 +1,51 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color } from '../../../../base/common/color.js';
import { registerColor, darken, lighten, transparent, ifDefinedThenElse } from '../colorUtils.js';
// Import the colors we need
import { foreground, contrastBorder, activeContrastBorder, focusBorder, iconForeground } from './baseColors.js';
import { editorWidgetBackground, editorFindMatchHighlightBorder, editorFindMatchHighlight, widgetShadow, editorWidgetForeground } from './editorColors.js';
export const listFocusBackground = registerColor('list.focusBackground', null, nls.localize(1923, "List/Tree background color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
export const listFocusForeground = registerColor('list.focusForeground', null, nls.localize(1924, "List/Tree foreground color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
export const listFocusOutline = registerColor('list.focusOutline', { dark: focusBorder, light: focusBorder, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1925, "List/Tree outline color for the focused item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
export const listFocusAndSelectionOutline = registerColor('list.focusAndSelectionOutline', null, nls.localize(1926, "List/Tree outline color for the focused item when the list/tree is active and selected. An active list/tree has keyboard focus, an inactive does not."));
export const listActiveSelectionBackground = registerColor('list.activeSelectionBackground', { dark: '#04395E', light: '#0060C0', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, nls.localize(1927, "List/Tree background color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
export const listActiveSelectionForeground = registerColor('list.activeSelectionForeground', { dark: Color.white, light: Color.white, hcDark: null, hcLight: null }, nls.localize(1928, "List/Tree foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
export const listActiveSelectionIconForeground = registerColor('list.activeSelectionIconForeground', null, nls.localize(1929, "List/Tree icon foreground color for the selected item when the list/tree is active. An active list/tree has keyboard focus, an inactive does not."));
export const listInactiveSelectionBackground = registerColor('list.inactiveSelectionBackground', { dark: '#37373D', light: '#E4E6F1', hcDark: null, hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, nls.localize(1930, "List/Tree background color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
export const listInactiveSelectionForeground = registerColor('list.inactiveSelectionForeground', null, nls.localize(1931, "List/Tree foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
export const listInactiveSelectionIconForeground = registerColor('list.inactiveSelectionIconForeground', null, nls.localize(1932, "List/Tree icon foreground color for the selected item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
export const listInactiveFocusBackground = registerColor('list.inactiveFocusBackground', null, nls.localize(1933, "List/Tree background color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
export const listInactiveFocusOutline = registerColor('list.inactiveFocusOutline', null, nls.localize(1934, "List/Tree outline color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not."));
export const listHoverBackground = registerColor('list.hoverBackground', { dark: '#2A2D2E', light: '#F0F0F0', hcDark: Color.white.transparent(0.1), hcLight: Color.fromHex('#0F4A85').transparent(0.1) }, nls.localize(1935, "List/Tree background when hovering over items using the mouse."));
export const listHoverForeground = registerColor('list.hoverForeground', null, nls.localize(1936, "List/Tree foreground when hovering over items using the mouse."));
export const listDropOverBackground = registerColor('list.dropBackground', { dark: '#062F4A', light: '#D6EBFF', hcDark: null, hcLight: null }, nls.localize(1937, "List/Tree drag and drop background when moving items over other items when using the mouse."));
export const listDropBetweenBackground = registerColor('list.dropBetweenBackground', { dark: iconForeground, light: iconForeground, hcDark: null, hcLight: null }, nls.localize(1938, "List/Tree drag and drop border color when moving items between items when using the mouse."));
export const listHighlightForeground = registerColor('list.highlightForeground', { dark: '#2AAAFF', light: '#0066BF', hcDark: focusBorder, hcLight: focusBorder }, nls.localize(1939, 'List/Tree foreground color of the match highlights when searching inside the list/tree.'));
export const listFocusHighlightForeground = registerColor('list.focusHighlightForeground', { dark: listHighlightForeground, light: ifDefinedThenElse(listActiveSelectionBackground, listHighlightForeground, '#BBE7FF'), hcDark: listHighlightForeground, hcLight: listHighlightForeground }, nls.localize(1940, 'List/Tree foreground color of the match highlights on actively focused items when searching inside the list/tree.'));
export const listInvalidItemForeground = registerColor('list.invalidItemForeground', { dark: '#B89500', light: '#B89500', hcDark: '#B89500', hcLight: '#B5200D' }, nls.localize(1941, 'List/Tree foreground color for invalid items, for example an unresolved root in explorer.'));
export const listErrorForeground = registerColor('list.errorForeground', { dark: '#F88070', light: '#B01011', hcDark: null, hcLight: null }, nls.localize(1942, 'Foreground color of list items containing errors.'));
export const listWarningForeground = registerColor('list.warningForeground', { dark: '#CCA700', light: '#855F00', hcDark: null, hcLight: null }, nls.localize(1943, 'Foreground color of list items containing warnings.'));
export const listFilterWidgetBackground = registerColor('listFilterWidget.background', { light: darken(editorWidgetBackground, 0), dark: lighten(editorWidgetBackground, 0), hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, nls.localize(1944, 'Background color of the type filter widget in lists and trees.'));
export const listFilterWidgetOutline = registerColor('listFilterWidget.outline', { dark: Color.transparent, light: Color.transparent, hcDark: '#f38518', hcLight: '#007ACC' }, nls.localize(1945, 'Outline color of the type filter widget in lists and trees.'));
export const listFilterWidgetNoMatchesOutline = registerColor('listFilterWidget.noMatchesOutline', { dark: '#BE1100', light: '#BE1100', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1946, 'Outline color of the type filter widget in lists and trees, when there are no matches.'));
export const listFilterWidgetShadow = registerColor('listFilterWidget.shadow', widgetShadow, nls.localize(1947, 'Shadow color of the type filter widget in lists and trees.'));
export const listFilterMatchHighlight = registerColor('list.filterMatchBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, nls.localize(1948, 'Background color of the filtered match.'));
export const listFilterMatchHighlightBorder = registerColor('list.filterMatchBorder', { dark: editorFindMatchHighlightBorder, light: editorFindMatchHighlightBorder, hcDark: contrastBorder, hcLight: activeContrastBorder }, nls.localize(1949, 'Border color of the filtered match.'));
export const listDeemphasizedForeground = registerColor('list.deemphasizedForeground', { dark: '#8C8C8C', light: '#8E8E90', hcDark: '#A7A8A9', hcLight: '#666666' }, nls.localize(1950, "List/Tree foreground color for items that are deemphasized."));
// ------ tree
export const treeIndentGuidesStroke = registerColor('tree.indentGuidesStroke', { dark: '#585858', light: '#a9a9a9', hcDark: '#a9a9a9', hcLight: '#a5a5a5' }, nls.localize(1951, "Tree stroke color for the indentation guides."));
export const treeInactiveIndentGuidesStroke = registerColor('tree.inactiveIndentGuidesStroke', transparent(treeIndentGuidesStroke, 0.4), nls.localize(1952, "Tree stroke color for the indentation guides that are not active."));
// ------ table
export const tableColumnsBorder = registerColor('tree.tableColumnsBorder', { dark: '#CCCCCC20', light: '#61616120', hcDark: null, hcLight: null }, nls.localize(1953, "Table border color between columns."));
export const tableOddRowsBackgroundColor = registerColor('tree.tableOddRowsBackground', { dark: transparent(foreground, 0.04), light: transparent(foreground, 0.04), hcDark: null, hcLight: null }, nls.localize(1954, "Background color for odd table rows."));
// ------ action list
export const editorActionListBackground = registerColor('editorActionList.background', editorWidgetBackground, nls.localize(1955, "Action List background color."));
export const editorActionListForeground = registerColor('editorActionList.foreground', editorWidgetForeground, nls.localize(1956, "Action List foreground color."));
export const editorActionListFocusForeground = registerColor('editorActionList.focusForeground', listActiveSelectionForeground, nls.localize(1957, "Action List foreground color for the focused item."));
export const editorActionListFocusBackground = registerColor('editorActionList.focusBackground', listActiveSelectionBackground, nls.localize(1958, "Action List background color for the focused item."));
//# sourceMappingURL=listColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/listColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

19
_internal/editor/esm/vs/platform/theme/common/colors/menuColors.js Normal file
View File

@@ -0,0 +1,19 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { registerColor } from '../colorUtils.js';
// Import the colors we need
import { contrastBorder, activeContrastBorder } from './baseColors.js';
import { selectForeground, selectBackground } from './inputColors.js';
import { listActiveSelectionBackground, listActiveSelectionForeground } from './listColors.js';
export const menuBorder = registerColor('menu.border', { dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1959, "Border color of menus."));
export const menuForeground = registerColor('menu.foreground', selectForeground, nls.localize(1960, "Foreground color of menu items."));
export const menuBackground = registerColor('menu.background', selectBackground, nls.localize(1961, "Background color of menu items."));
export const menuSelectionForeground = registerColor('menu.selectionForeground', listActiveSelectionForeground, nls.localize(1962, "Foreground color of the selected menu item in menus."));
export const menuSelectionBackground = registerColor('menu.selectionBackground', listActiveSelectionBackground, nls.localize(1963, "Background color of the selected menu item in menus."));
export const menuSelectionBorder = registerColor('menu.selectionBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize(1964, "Border color of the selected menu item in menus."));
export const menuSeparatorBackground = registerColor('menu.separatorBackground', { dark: '#606060', light: '#D4D4D4', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1965, "Color of a separator menu item in menus."));
//# sourceMappingURL=menuColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/menuColors.js.map Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["vs/platform/theme/common/colors/menuColors.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAE1C,6BAA6B;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,4BAA4B;AAC5B,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAG/F,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CAAC,aAAa,EACpD,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAE,EAC5E,GAAG,CAAC,QAAQ,CAAC,IAAY,EAAE,wBAAwB,CAAC,CAAC,CAAC;AAEvD,MAAM,CAAC,MAAM,cAAc,GAAG,aAAa,CAAC,iBAAiB,EAC5D,gBAAgB,EAChB,GAAG,CAAC,QAAQ,CAAC,IAAgB,EAAE,iCAAiC,CAAC,CAAC,CAAC;AAEpE,MAAM,CAAC,MAAM,cAAc,GAAG,aAAa,CAAC,iBAAiB,EAC5D,gBAAgB,EAChB,GAAG,CAAC,QAAQ,CAAC,IAAgB,EAAE,iCAAiC,CAAC,CAAC,CAAC;AAEpE,MAAM,CAAC,MAAM,uBAAuB,GAAG,aAAa,CAAC,0BAA0B,EAC9E,6BAA6B,EAC7B,GAAG,CAAC,QAAQ,CAAC,IAAyB,EAAE,sDAAsD,CAAC,CAAC,CAAC;AAElG,MAAM,CAAC,MAAM,uBAAuB,GAAG,aAAa,CAAC,0BAA0B,EAC9E,6BAA6B,EAC7B,GAAG,CAAC,QAAQ,CAAC,IAAyB,EAAE,sDAAsD,CAAC,CAAC,CAAC;AAElG,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAAC,sBAAsB,EACtE,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,EAAE,EACxF,GAAG,CAAC,QAAQ,CAAC,IAAqB,EAAE,kDAAkD,CAAC,CAAC,CAAC;AAE1F,MAAM,CAAC,MAAM,uBAAuB,GAAG,aAAa,CAAC,0BAA0B,EAC9E,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAE,EACtF,GAAG,CAAC,QAAQ,CAAC,IAAyB,EAAE,0CAA0C,CAAC,CAAC,CAAC","file":"menuColors.js","sourceRoot":"file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nimport * as nls from '../../../../nls.js';\n\n// Import the effects we need\nimport { registerColor } from '../colorUtils.js';\n\n// Import the colors we need\nimport { contrastBorder, activeContrastBorder } from './baseColors.js';\nimport { selectForeground, selectBackground } from './inputColors.js';\nimport { listActiveSelectionBackground, listActiveSelectionForeground } from './listColors.js';\n\n\nexport const menuBorder = registerColor('menu.border',\n\t{ dark: null, light: null, hcDark: contrastBorder, hcLight: contrastBorder },\n\tnls.localize('menuBorder', \"Border color of menus.\"));\n\nexport const menuForeground = registerColor('menu.foreground',\n\tselectForeground,\n\tnls.localize('menuForeground', \"Foreground color of menu items.\"));\n\nexport const menuBackground = registerColor('menu.background',\n\tselectBackground,\n\tnls.localize('menuBackground', \"Background color of menu items.\"));\n\nexport const menuSelectionForeground = registerColor('menu.selectionForeground',\n\tlistActiveSelectionForeground,\n\tnls.localize('menuSelectionForeground', \"Foreground color of the selected menu item in menus.\"));\n\nexport const menuSelectionBackground = registerColor('menu.selectionBackground',\n\tlistActiveSelectionBackground,\n\tnls.localize('menuSelectionBackground', \"Background color of the selected menu item in menus.\"));\n\nexport const menuSelectionBorder = registerColor('menu.selectionBorder',\n\t{ dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder },\n\tnls.localize('menuSelectionBorder', \"Border color of the selected menu item in menus.\"));\n\nexport const menuSeparatorBackground = registerColor('menu.separatorBackground',\n\t{ dark: '#606060', light: '#D4D4D4', hcDark: contrastBorder, hcLight: contrastBorder },\n\tnls.localize('menuSeparatorBackground', \"Color of a separator menu item in menus.\"));\n"]}

23
_internal/editor/esm/vs/platform/theme/common/colors/minimapColors.js Normal file
View File

@@ -0,0 +1,23 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color, RGBA } from '../../../../base/common/color.js';
import { registerColor, transparent } from '../colorUtils.js';
// Import the colors we need
import { editorInfoForeground, editorWarningForeground, editorWarningBorder, editorInfoBorder } from './editorColors.js';
import { scrollbarSliderBackground, scrollbarSliderHoverBackground, scrollbarSliderActiveBackground } from './miscColors.js';
export const minimapFindMatch = registerColor('minimap.findMatchHighlight', { light: '#d18616', dark: '#d18616', hcDark: '#AB5A00', hcLight: '#0F4A85' }, nls.localize(1966, 'Minimap marker color for find matches.'), true);
export const minimapSelectionOccurrenceHighlight = registerColor('minimap.selectionOccurrenceHighlight', { light: '#c9c9c9', dark: '#676767', hcDark: '#ffffff', hcLight: '#0F4A85' }, nls.localize(1967, 'Minimap marker color for repeating editor selections.'), true);
export const minimapSelection = registerColor('minimap.selectionHighlight', { light: '#ADD6FF', dark: '#264F78', hcDark: '#ffffff', hcLight: '#0F4A85' }, nls.localize(1968, 'Minimap marker color for the editor selection.'), true);
export const minimapInfo = registerColor('minimap.infoHighlight', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, nls.localize(1969, 'Minimap marker color for infos.'));
export const minimapWarning = registerColor('minimap.warningHighlight', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, nls.localize(1970, 'Minimap marker color for warnings.'));
export const minimapError = registerColor('minimap.errorHighlight', { dark: new Color(new RGBA(255, 18, 18, 0.7)), light: new Color(new RGBA(255, 18, 18, 0.7)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '#B5200D' }, nls.localize(1971, 'Minimap marker color for errors.'));
export const minimapBackground = registerColor('minimap.background', null, nls.localize(1972, "Minimap background color."));
export const minimapForegroundOpacity = registerColor('minimap.foregroundOpacity', Color.fromHex('#000f'), nls.localize(1973, 'Opacity of foreground elements rendered in the minimap. For example, "#000000c0" will render the elements with 75% opacity.'));
export const minimapSliderBackground = registerColor('minimapSlider.background', transparent(scrollbarSliderBackground, 0.5), nls.localize(1974, "Minimap slider background color."));
export const minimapSliderHoverBackground = registerColor('minimapSlider.hoverBackground', transparent(scrollbarSliderHoverBackground, 0.5), nls.localize(1975, "Minimap slider background color when hovering."));
export const minimapSliderActiveBackground = registerColor('minimapSlider.activeBackground', transparent(scrollbarSliderActiveBackground, 0.5), nls.localize(1976, "Minimap slider background color when clicked on."));
//# sourceMappingURL=minimapColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/minimapColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

31
_internal/editor/esm/vs/platform/theme/common/colors/miscColors.js Normal file
View File

@@ -0,0 +1,31 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color } from '../../../../base/common/color.js';
import { registerColor, transparent } from '../colorUtils.js';
// Import the colors we need
import { contrastBorder, focusBorder } from './baseColors.js';
// ----- sash
export const sashHoverBorder = registerColor('sash.hoverBorder', focusBorder, nls.localize(1977, "Border color of active sashes."));
// ----- badge
export const badgeBackground = registerColor('badge.background', { dark: '#4D4D4D', light: '#C4C4C4', hcDark: Color.black, hcLight: '#0F4A85' }, nls.localize(1978, "Badge background color. Badges are small information labels, e.g. for search results count."));
export const badgeForeground = registerColor('badge.foreground', { dark: Color.white, light: '#333', hcDark: Color.white, hcLight: Color.white }, nls.localize(1979, "Badge foreground color. Badges are small information labels, e.g. for search results count."));
export const activityWarningBadgeForeground = registerColor('activityWarningBadge.foreground', { dark: Color.black.lighten(0.2), light: Color.white, hcDark: null, hcLight: Color.black.lighten(0.2) }, nls.localize(1980, 'Foreground color of the warning activity badge'));
export const activityWarningBadgeBackground = registerColor('activityWarningBadge.background', { dark: '#CCA700', light: '#BF8803', hcDark: null, hcLight: '#CCA700' }, nls.localize(1981, 'Background color of the warning activity badge'));
export const activityErrorBadgeForeground = registerColor('activityErrorBadge.foreground', { dark: Color.black.lighten(0.2), light: Color.white, hcDark: null, hcLight: Color.black.lighten(0.2) }, nls.localize(1982, 'Foreground color of the error activity badge'));
export const activityErrorBadgeBackground = registerColor('activityErrorBadge.background', { dark: '#F14C4C', light: '#E51400', hcDark: null, hcLight: '#F14C4C' }, nls.localize(1983, 'Background color of the error activity badge'));
// ----- scrollbar
export const scrollbarShadow = registerColor('scrollbar.shadow', { dark: '#000000', light: '#DDDDDD', hcDark: null, hcLight: null }, nls.localize(1984, "Scrollbar shadow to indicate that the view is scrolled."));
export const scrollbarSliderBackground = registerColor('scrollbarSlider.background', { dark: Color.fromHex('#797979').transparent(0.4), light: Color.fromHex('#646464').transparent(0.4), hcDark: transparent(contrastBorder, 0.6), hcLight: transparent(contrastBorder, 0.4) }, nls.localize(1985, "Scrollbar slider background color."));
export const scrollbarSliderHoverBackground = registerColor('scrollbarSlider.hoverBackground', { dark: Color.fromHex('#646464').transparent(0.7), light: Color.fromHex('#646464').transparent(0.7), hcDark: transparent(contrastBorder, 0.8), hcLight: transparent(contrastBorder, 0.8) }, nls.localize(1986, "Scrollbar slider background color when hovering."));
export const scrollbarSliderActiveBackground = registerColor('scrollbarSlider.activeBackground', { dark: Color.fromHex('#BFBFBF').transparent(0.4), light: Color.fromHex('#000000').transparent(0.6), hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1987, "Scrollbar slider background color when clicked on."));
// ----- progress bar
export const progressBarBackground = registerColor('progressBar.background', { dark: Color.fromHex('#0E70C0'), light: Color.fromHex('#0E70C0'), hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1988, "Background color of the progress bar that can show for long running operations."));
// ----- chart
export const chartLine = registerColor('chart.line', { dark: '#236B8E', light: '#236B8E', hcDark: '#236B8E', hcLight: '#236B8E' }, nls.localize(1989, "Line color for the chart."));
export const chartAxis = registerColor('chart.axis', { dark: Color.fromHex('#BFBFBF').transparent(0.4), light: Color.fromHex('#000000').transparent(0.6), hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1990, "Axis color for the chart."));
export const chartGuide = registerColor('chart.guide', { dark: Color.fromHex('#BFBFBF').transparent(0.2), light: Color.fromHex('#000000').transparent(0.2), hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize(1991, "Guide line for the chart."));
//# sourceMappingURL=miscColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/miscColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

21
_internal/editor/esm/vs/platform/theme/common/colors/quickpickColors.js Normal file
View File

@@ -0,0 +1,21 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { Color, RGBA } from '../../../../base/common/color.js';
import { registerColor, oneOf } from '../colorUtils.js';
// Import the colors we need
import { editorWidgetBackground, editorWidgetForeground } from './editorColors.js';
import { listActiveSelectionBackground, listActiveSelectionForeground, listActiveSelectionIconForeground } from './listColors.js';
export const quickInputBackground = registerColor('quickInput.background', editorWidgetBackground, nls.localize(1992, "Quick picker background color. The quick picker widget is the container for pickers like the command palette."));
export const quickInputForeground = registerColor('quickInput.foreground', editorWidgetForeground, nls.localize(1993, "Quick picker foreground color. The quick picker widget is the container for pickers like the command palette."));
export const quickInputTitleBackground = registerColor('quickInputTitle.background', { dark: new Color(new RGBA(255, 255, 255, 0.105)), light: new Color(new RGBA(0, 0, 0, 0.06)), hcDark: '#000000', hcLight: Color.white }, nls.localize(1994, "Quick picker title background color. The quick picker widget is the container for pickers like the command palette."));
export const pickerGroupForeground = registerColor('pickerGroup.foreground', { dark: '#3794FF', light: '#0066BF', hcDark: Color.white, hcLight: '#0F4A85' }, nls.localize(1995, "Quick picker color for grouping labels."));
export const pickerGroupBorder = registerColor('pickerGroup.border', { dark: '#3F3F46', light: '#CCCEDB', hcDark: Color.white, hcLight: '#0F4A85' }, nls.localize(1996, "Quick picker color for grouping borders."));
export const _deprecatedQuickInputListFocusBackground = registerColor('quickInput.list.focusBackground', null, '', undefined, nls.localize(1997, "Please use quickInputList.focusBackground instead"));
export const quickInputListFocusForeground = registerColor('quickInputList.focusForeground', listActiveSelectionForeground, nls.localize(1998, "Quick picker foreground color for the focused item."));
export const quickInputListFocusIconForeground = registerColor('quickInputList.focusIconForeground', listActiveSelectionIconForeground, nls.localize(1999, "Quick picker icon foreground color for the focused item."));
export const quickInputListFocusBackground = registerColor('quickInputList.focusBackground', { dark: oneOf(_deprecatedQuickInputListFocusBackground, listActiveSelectionBackground), light: oneOf(_deprecatedQuickInputListFocusBackground, listActiveSelectionBackground), hcDark: null, hcLight: null }, nls.localize(2000, "Quick picker background color for the focused item."));
//# sourceMappingURL=quickpickColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/quickpickColors.js.map Normal file
View File

File diff suppressed because one or more lines are too long

15
_internal/editor/esm/vs/platform/theme/common/colors/searchColors.js Normal file
View File

@@ -0,0 +1,15 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as nls from '../../../../nls.js';
// Import the effects we need
import { registerColor, transparent } from '../colorUtils.js';
// Import the colors we need
import { foreground } from './baseColors.js';
import { editorFindMatchHighlight, editorFindMatchHighlightBorder } from './editorColors.js';
export const searchResultsInfoForeground = registerColor('search.resultsInfoForeground', { light: foreground, dark: transparent(foreground, 0.65), hcDark: foreground, hcLight: foreground }, nls.localize(2001, "Color of the text in the search viewlet's completion message."));
// ----- search editor (Distinct from normal editor find match to allow for better differentiation)
export const searchEditorFindMatch = registerColor('searchEditor.findMatchBackground', { light: transparent(editorFindMatchHighlight, 0.66), dark: transparent(editorFindMatchHighlight, 0.66), hcDark: editorFindMatchHighlight, hcLight: editorFindMatchHighlight }, nls.localize(2002, "Color of the Search Editor query matches."));
export const searchEditorFindMatchBorder = registerColor('searchEditor.findMatchBorder', { light: transparent(editorFindMatchHighlightBorder, 0.66), dark: transparent(editorFindMatchHighlightBorder, 0.66), hcDark: editorFindMatchHighlightBorder, hcLight: editorFindMatchHighlightBorder }, nls.localize(2003, "Border color of the Search Editor query matches."));
//# sourceMappingURL=searchColors.js.map

1
_internal/editor/esm/vs/platform/theme/common/colors/searchColors.js.map Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["vs/platform/theme/common/colors/searchColors.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG,OAAO,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAE1C,6BAA6B;AAC7B,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE9D,4BAA4B;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,wBAAwB,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAG7F,MAAM,CAAC,MAAM,2BAA2B,GAAG,aAAa,CAAC,8BAA8B,EACtF,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,EACnG,GAAG,CAAC,QAAQ,CAAC,IAA8B,EAAE,+DAA+D,CAAC,CAAC,CAAC;AAGhH,mGAAmG;AAEnG,MAAM,CAAC,MAAM,qBAAqB,GAAG,aAAa,CAAC,kCAAkC,EACpF,EAAE,KAAK,EAAE,WAAW,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,wBAAwB,EAAE,OAAO,EAAE,wBAAwB,EAAE,EAC9K,GAAG,CAAC,QAAQ,CAAC,IAAyB,EAAE,2CAA2C,CAAC,CAAC,CAAC;AAEvF,MAAM,CAAC,MAAM,2BAA2B,GAAG,aAAa,CAAC,8BAA8B,EACtF,EAAE,KAAK,EAAE,WAAW,CAAC,8BAA8B,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,8BAA8B,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,8BAA8B,EAAE,OAAO,EAAE,8BAA8B,EAAE,EACtM,GAAG,CAAC,QAAQ,CAAC,IAAoC,EAAE,kDAAkD,CAAC,CAAC,CAAC","file":"searchColors.js","sourceRoot":"file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\nimport * as nls from '../../../../nls.js';\n\n// Import the effects we need\nimport { registerColor, transparent } from '../colorUtils.js';\n\n// Import the colors we need\nimport { foreground } from './baseColors.js';\nimport { editorFindMatchHighlight, editorFindMatchHighlightBorder } from './editorColors.js';\n\n\nexport const searchResultsInfoForeground = registerColor('search.resultsInfoForeground',\n\t{ light: foreground, dark: transparent(foreground, 0.65), hcDark: foreground, hcLight: foreground },\n\tnls.localize('search.resultsInfoForeground', \"Color of the text in the search viewlet's completion message.\"));\n\n\n// ----- search editor (Distinct from normal editor find match to allow for better differentiation)\n\nexport const searchEditorFindMatch = registerColor('searchEditor.findMatchBackground',\n\t{ light: transparent(editorFindMatchHighlight, 0.66), dark: transparent(editorFindMatchHighlight, 0.66), hcDark: editorFindMatchHighlight, hcLight: editorFindMatchHighlight },\n\tnls.localize('searchEditor.queryMatch', \"Color of the Search Editor query matches.\"));\n\nexport const searchEditorFindMatchBorder = registerColor('searchEditor.findMatchBorder',\n\t{ light: transparent(editorFindMatchHighlightBorder, 0.66), dark: transparent(editorFindMatchHighlightBorder, 0.66), hcDark: editorFindMatchHighlightBorder, hcLight: editorFindMatchHighlightBorder },\n\tnls.localize('searchEditor.editorFindMatchBorder', \"Border color of the Search Editor query matches.\"));\n"]}

181
_internal/editor/esm/vs/platform/theme/common/iconRegistry.js Normal file
View File

@@ -0,0 +1,181 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { RunOnceScheduler } from '../../../base/common/async.js';
import { Codicon } from '../../../base/common/codicons.js';
import { getCodiconFontCharacters } from '../../../base/common/codiconsUtil.js';
import { ThemeIcon } from '../../../base/common/themables.js';
import { Emitter } from '../../../base/common/event.js';
import { isString } from '../../../base/common/types.js';
import { URI } from '../../../base/common/uri.js';
import { localize } from '../../../nls.js';
import { Extensions as JSONExtensions } from '../../jsonschemas/common/jsonContributionRegistry.js';
import * as platform from '../../registry/common/platform.js';
import { Disposable } from '../../../base/common/lifecycle.js';
// ------ API types
// icon registry
export const Extensions = {
IconContribution: 'base.contributions.icons'
};
export var IconContribution;
(function (IconContribution) {
function getDefinition(contribution, registry) {
let definition = contribution.defaults;
while (ThemeIcon.isThemeIcon(definition)) {
const c = iconRegistry.getIcon(definition.id);
if (!c) {
return undefined;
}
definition = c.defaults;
}
return definition;
}
IconContribution.getDefinition = getDefinition;
})(IconContribution || (IconContribution = {}));
export var IconFontDefinition;
(function (IconFontDefinition) {
function toJSONObject(iconFont) {
return {
weight: iconFont.weight,
style: iconFont.style,
src: iconFont.src.map(s => ({ format: s.format, location: s.location.toString() }))
};
}
IconFontDefinition.toJSONObject = toJSONObject;
function fromJSONObject(json) {
const stringOrUndef = (s) => isString(s) ? s : undefined;
if (json && Array.isArray(json.src) && json.src.every((s) => isString(s.format) && isString(s.location))) {
return {
weight: stringOrUndef(json.weight),
style: stringOrUndef(json.style),
src: json.src.map((s) => ({ format: s.format, location: URI.parse(s.location) }))
};
}
return undefined;
}
IconFontDefinition.fromJSONObject = fromJSONObject;
})(IconFontDefinition || (IconFontDefinition = {}));
// regexes for validation of font properties
export const fontIdRegex = /^([\w_-]+)$/;
export const fontIdErrorMessage = localize(2006, 'The font ID must only contain letters, numbers, underscores and dashes.');
class IconRegistry extends Disposable {
constructor() {
super();
this._onDidChange = this._register(new Emitter());
this.onDidChange = this._onDidChange.event;
this.iconSchema = {
definitions: {
icons: {
type: 'object',
properties: {
fontId: { type: 'string', description: localize(2007, 'The id of the font to use. If not set, the font that is defined first is used.'), pattern: fontIdRegex.source, patternErrorMessage: fontIdErrorMessage },
fontCharacter: { type: 'string', description: localize(2008, 'The font character associated with the icon definition.') }
},
additionalProperties: false,
defaultSnippets: [{ body: { fontCharacter: '\\\\e030' } }]
}
},
type: 'object',
properties: {}
};
this.iconReferenceSchema = { type: 'string', pattern: `^${ThemeIcon.iconNameExpression}$`, enum: [], enumDescriptions: [] };
this.iconsById = {};
this.iconFontsById = {};
}
registerIcon(id, defaults, description, deprecationMessage) {
const existing = this.iconsById[id];
if (existing) {
if (description && !existing.description) {
existing.description = description;
this.iconSchema.properties[id].markdownDescription = `${description} $(${id})`;
const enumIndex = this.iconReferenceSchema.enum.indexOf(id);
if (enumIndex !== -1) {
this.iconReferenceSchema.enumDescriptions[enumIndex] = description;
}
this._onDidChange.fire();
}
return existing;
}
const iconContribution = { id, description, defaults, deprecationMessage };
this.iconsById[id] = iconContribution;
const propertySchema = { $ref: '#/definitions/icons' };
if (deprecationMessage) {
propertySchema.deprecationMessage = deprecationMessage;
}
if (description) {
propertySchema.markdownDescription = `${description}: $(${id})`;
}
this.iconSchema.properties[id] = propertySchema;
this.iconReferenceSchema.enum.push(id);
this.iconReferenceSchema.enumDescriptions.push(description || '');
this._onDidChange.fire();
return { id };
}
getIcons() {
return Object.keys(this.iconsById).map(id => this.iconsById[id]);
}
getIcon(id) {
return this.iconsById[id];
}
getIconSchema() {
return this.iconSchema;
}
toString() {
const sorter = (i1, i2) => {
return i1.id.localeCompare(i2.id);
};
const classNames = (i) => {
while (ThemeIcon.isThemeIcon(i.defaults)) {
i = this.iconsById[i.defaults.id];
}
return `codicon codicon-${i ? i.id : ''}`;
};
const reference = [];
reference.push(`| preview | identifier | default codicon ID | description`);
reference.push(`| ----------- | --------------------------------- | --------------------------------- | --------------------------------- |`);
const contributions = Object.keys(this.iconsById).map(key => this.iconsById[key]);
for (const i of contributions.filter(i => !!i.description).sort(sorter)) {
reference.push(`|<i class="${classNames(i)}"></i>|${i.id}|${ThemeIcon.isThemeIcon(i.defaults) ? i.defaults.id : i.id}|${i.description || ''}|`);
}
reference.push(`| preview | identifier `);
reference.push(`| ----------- | --------------------------------- |`);
for (const i of contributions.filter(i => !ThemeIcon.isThemeIcon(i.defaults)).sort(sorter)) {
reference.push(`|<i class="${classNames(i)}"></i>|${i.id}|`);
}
return reference.join('\n');
}
}
const iconRegistry = new IconRegistry();
platform.Registry.add(Extensions.IconContribution, iconRegistry);
export function registerIcon(id, defaults, description, deprecationMessage) {
return iconRegistry.registerIcon(id, defaults, description, deprecationMessage);
}
export function getIconRegistry() {
return iconRegistry;
}
function initialize() {
const codiconFontCharacters = getCodiconFontCharacters();
for (const icon in codiconFontCharacters) {
const fontCharacter = '\\' + codiconFontCharacters[icon].toString(16);
iconRegistry.registerIcon(icon, { fontCharacter });
}
}
initialize();
export const iconsSchemaId = 'vscode://schemas/icons';
const schemaRegistry = platform.Registry.as(JSONExtensions.JSONContribution);
schemaRegistry.registerSchema(iconsSchemaId, iconRegistry.getIconSchema());
const delayer = new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(iconsSchemaId), 200);
iconRegistry.onDidChange(() => {
if (!delayer.isScheduled()) {
delayer.schedule();
}
});
//setTimeout(_ => console.log(iconRegistry.toString()), 5000);
// common icons
export const widgetClose = registerIcon('widget-close', Codicon.close, localize(2009, 'Icon for the close action in widgets.'));
export const gotoPreviousLocation = registerIcon('goto-previous-location', Codicon.arrowUp, localize(2010, 'Icon for goto previous editor location.'));
export const gotoNextLocation = registerIcon('goto-next-location', Codicon.arrowDown, localize(2011, 'Icon for goto next editor location.'));
export const syncing = ThemeIcon.modify(Codicon.sync, 'spin');
export const spinningLoading = ThemeIcon.modify(Codicon.loading, 'spin');
//# sourceMappingURL=iconRegistry.js.map

1
_internal/editor/esm/vs/platform/theme/common/iconRegistry.js.map Normal file
View File

File diff suppressed because one or more lines are too long

28
_internal/editor/esm/vs/platform/theme/common/theme.js Normal file
View File

@@ -0,0 +1,28 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
/**
* Color scheme used by the OS and by color themes.
*/
export var ColorScheme;
(function (ColorScheme) {
ColorScheme["DARK"] = "dark";
ColorScheme["LIGHT"] = "light";
ColorScheme["HIGH_CONTRAST_DARK"] = "hcDark";
ColorScheme["HIGH_CONTRAST_LIGHT"] = "hcLight";
})(ColorScheme || (ColorScheme = {}));
export var ThemeTypeSelector;
(function (ThemeTypeSelector) {
ThemeTypeSelector["VS"] = "vs";
ThemeTypeSelector["VS_DARK"] = "vs-dark";
ThemeTypeSelector["HC_BLACK"] = "hc-black";
ThemeTypeSelector["HC_LIGHT"] = "hc-light";
})(ThemeTypeSelector || (ThemeTypeSelector = {}));
export function isHighContrast(scheme) {
return scheme === ColorScheme.HIGH_CONTRAST_DARK || scheme === ColorScheme.HIGH_CONTRAST_LIGHT;
}
export function isDark(scheme) {
return scheme === ColorScheme.DARK || scheme === ColorScheme.HIGH_CONTRAST_DARK;
}
//# sourceMappingURL=theme.js.map

1
_internal/editor/esm/vs/platform/theme/common/theme.js.map Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src/vs/platform/theme/common/theme.ts","vs/platform/theme/common/theme.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAEhG;;GAEG;AACH,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACtB,4BAAa,CAAA;IACb,8BAAe,CAAA;IACf,4CAA6B,CAAA;IAC7B,8CAA+B,CAAA;AAChC,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED,MAAM,CAAN,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC5B,8BAAS,CAAA;IACT,wCAAmB,CAAA;IACnB,0CAAqB,CAAA;IACrB,0CAAqB,CAAA;AACtB,CAAC,EALW,iBAAiB,KAAjB,iBAAiB,QAK5B;AAGD,MAAM,UAAU,cAAc,CAAC,MAAmB;IACjD,OAAO,MAAM,KAAK,WAAW,CAAC,kBAAkB,IAAI,MAAM,KAAK,WAAW,CAAC,mBAAmB,CAAC;AAChG,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,MAAmB;IACzC,OAAO,MAAM,KAAK,WAAW,CAAC,IAAI,IAAI,MAAM,KAAK,WAAW,CAAC,kBAAkB,CAAC;AACjF,CAAC","file":"theme.js","sourceRoot":"file:///mnt/vss/_work/1/s/dependencies/vscode/out-editor-src","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/**\n * Color scheme used by the OS and by color themes.\n */\nexport enum ColorScheme {\n\tDARK = 'dark',\n\tLIGHT = 'light',\n\tHIGH_CONTRAST_DARK = 'hcDark',\n\tHIGH_CONTRAST_LIGHT = 'hcLight'\n}\n\nexport enum ThemeTypeSelector {\n\tVS = 'vs',\n\tVS_DARK = 'vs-dark',\n\tHC_BLACK = 'hc-black',\n\tHC_LIGHT = 'hc-light'\n}\n\n\nexport function isHighContrast(scheme: ColorScheme): boolean {\n\treturn scheme === ColorScheme.HIGH_CONTRAST_DARK || scheme === ColorScheme.HIGH_CONTRAST_LIGHT;\n}\n\nexport function isDark(scheme: ColorScheme): boolean {\n\treturn scheme === ColorScheme.DARK || scheme === ColorScheme.HIGH_CONTRAST_DARK;\n}\n","/*---------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/**\n * Color scheme used by the OS and by color themes.\n */\nexport enum ColorScheme {\n\tDARK = 'dark',\n\tLIGHT = 'light',\n\tHIGH_CONTRAST_DARK = 'hcDark',\n\tHIGH_CONTRAST_LIGHT = 'hcLight'\n}\n\nexport enum ThemeTypeSelector {\n\tVS = 'vs',\n\tVS_DARK = 'vs-dark',\n\tHC_BLACK = 'hc-black',\n\tHC_LIGHT = 'hc-light'\n}\n\n\nexport function isHighContrast(scheme: ColorScheme): boolean {\n\treturn scheme === ColorScheme.HIGH_CONTRAST_DARK || scheme === ColorScheme.HIGH_CONTRAST_LIGHT;\n}\n\nexport function isDark(scheme: ColorScheme): boolean {\n\treturn scheme === ColorScheme.DARK || scheme === ColorScheme.HIGH_CONTRAST_DARK;\n}\n"]}

65
_internal/editor/esm/vs/platform/theme/common/themeService.js Normal file
View File

@@ -0,0 +1,65 @@
import { Emitter } from '../../../base/common/event.js';
import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
import { createDecorator } from '../../instantiation/common/instantiation.js';
import * as platform from '../../registry/common/platform.js';
import { ColorScheme, ThemeTypeSelector } from './theme.js';
export const IThemeService = createDecorator('themeService');
export function themeColorFromId(id) {
return { id };
}
export function getThemeTypeSelector(type) {
switch (type) {
case ColorScheme.DARK: return ThemeTypeSelector.VS_DARK;
case ColorScheme.HIGH_CONTRAST_DARK: return ThemeTypeSelector.HC_BLACK;
case ColorScheme.HIGH_CONTRAST_LIGHT: return ThemeTypeSelector.HC_LIGHT;
default: return ThemeTypeSelector.VS;
}
}
// static theming participant
export const Extensions = {
ThemingContribution: 'base.contributions.theming'
};
class ThemingRegistry extends Disposable {
constructor() {
super();
this.themingParticipants = [];
this.themingParticipants = [];
this.onThemingParticipantAddedEmitter = this._register(new Emitter());
}
onColorThemeChange(participant) {
this.themingParticipants.push(participant);
this.onThemingParticipantAddedEmitter.fire(participant);
return toDisposable(() => {
const idx = this.themingParticipants.indexOf(participant);
this.themingParticipants.splice(idx, 1);
});
}
getThemingParticipants() {
return this.themingParticipants;
}
}
const themingRegistry = new ThemingRegistry();
platform.Registry.add(Extensions.ThemingContribution, themingRegistry);
export function registerThemingParticipant(participant) {
return themingRegistry.onColorThemeChange(participant);
}
/**
* Utility base class for all themable components.
*/
export class Themable extends Disposable {
constructor(themeService) {
super();
this.themeService = themeService;
this.theme = themeService.getColorTheme();
// Hook up to theme changes
this._register(this.themeService.onDidColorThemeChange(theme => this.onThemeChange(theme)));
}
onThemeChange(theme) {
this.theme = theme;
this.updateStyles();
}
updateStyles() {
// Subclasses to override
}
}
//# sourceMappingURL=themeService.js.map

1
_internal/editor/esm/vs/platform/theme/common/themeService.js.map Normal file
View File

File diff suppressed because one or more lines are too long