monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,102 +0,0 @@
-import { localize } from '../../../nls.js';
-import { Color, RGBA } from '../../../base/common/color.js';
-import { registerColor } from '../../../platform/theme/common/colorUtils.js';
-import { contrastBorder, activeContrastBorder } from '../../../platform/theme/common/colors/baseColors.js';
-import '../../../platform/theme/common/colors/chartsColors.js';
-import { editorFindMatchHighlight, editorBackground, editorWarningBorder, editorWarningForeground, editorInfoBorder, editorInfoForeground, editorWarningBackground } from '../../../platform/theme/common/colors/editorColors.js';
-import '../../../platform/theme/common/colors/inputColors.js';
-import '../../../platform/theme/common/colors/listColors.js';
-import '../../../platform/theme/common/colors/menuColors.js';
-import '../../../platform/theme/common/colors/minimapColors.js';
-import '../../../platform/theme/common/colors/miscColors.js';
-import '../../../platform/theme/common/colors/quickpickColors.js';
-import '../../../platform/theme/common/colors/searchColors.js';
-import { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Definition of the editor colors
- */
-const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, localize(610, 'Background color for the highlight of line at the cursor position.'));
-const editorLineHighlightBorder = registerColor('editor.lineHighlightBorder', { dark: '#282828', light: '#eeeeee', hcDark: '#f38518', hcLight: contrastBorder }, localize(611, 'Background color for the border around the line at the cursor position.'));
-registerColor('editor.rangeHighlightBackground', { dark: '#ffffff0b', light: '#fdff0033', hcDark: null, hcLight: null }, localize(612, 'Background color of highlighted ranges, like by quick open and find features. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(613, 'Background color of the border around highlighted ranges.'));
-registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, localize(614, 'Background color of highlighted symbol, like for go to definition or go next/previous symbol. The color must not be opaque so as not to hide underlying decorations.'), true);
-registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(615, 'Background color of the border around highlighted symbols.'));
-const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, localize(616, 'Color of the editor cursor.'));
-const editorCursorBackground = registerColor('editorCursor.background', null, localize(617, 'The background color of the editor cursor. Allows customizing the color of a character overlapped by a block cursor.'));
-const editorMultiCursorPrimaryForeground = registerColor('editorMultiCursor.primary.foreground', editorCursorForeground, localize(618, 'Color of the primary editor cursor when multiple cursors are present.'));
-const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, localize(619, 'The background color of the primary editor cursor when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'));
-const editorMultiCursorSecondaryForeground = registerColor('editorMultiCursor.secondary.foreground', editorCursorForeground, localize(620, 'Color of secondary editor cursors when multiple cursors are present.'));
-const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, localize(621, 'The background color of secondary editor cursors when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'));
-const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, localize(622, 'Color of whitespace characters in the editor.'));
-const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, localize(623, 'Color of editor line numbers.'));
-const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, localize(624, 'Color of the editor indentation guides.'), false, localize(625, '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'));
-const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, localize(626, 'Color of the active editor indentation guides.'), false, localize(627, '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'));
-const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, localize(628, 'Color of the editor indentation guides (1).'));
-const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', localize(629, 'Color of the editor indentation guides (2).'));
-const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', localize(630, 'Color of the editor indentation guides (3).'));
-const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', localize(631, 'Color of the editor indentation guides (4).'));
-const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', localize(632, 'Color of the editor indentation guides (5).'));
-const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', localize(633, 'Color of the editor indentation guides (6).'));
-const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, localize(634, 'Color of the active editor indentation guides (1).'));
-const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', localize(635, 'Color of the active editor indentation guides (2).'));
-const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', localize(636, 'Color of the active editor indentation guides (3).'));
-const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', localize(637, 'Color of the active editor indentation guides (4).'));
-const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', localize(638, 'Color of the active editor indentation guides (5).'));
-const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', localize(639, 'Color of the active editor indentation guides (6).'));
-const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, localize(640, 'Color of editor active line number'), false, localize(641, 'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'));
-registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, localize(642, 'Color of editor active line number'));
-const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, localize(643, 'Color of the final editor line when editor.renderFinalNewline is set to dimmed.'));
-const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, localize(644, 'Color of the editor rulers.'));
-registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, localize(645, 'Foreground color of editor CodeLens'));
-registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, localize(646, 'Background color behind matching brackets'));
-registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, localize(647, 'Color for matching brackets boxes'));
-const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, localize(648, 'Color of the overview ruler border.'));
-const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, localize(649, 'Background color of the editor overview ruler.'));
-registerColor('editorGutter.background', editorBackground, localize(650, 'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.'));
-registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: Color.fromHex('#fff').transparent(0.8), hcLight: contrastBorder }, localize(651, 'Border color of unnecessary (unused) source code in the editor.'));
-const editorUnnecessaryCodeOpacity = registerColor('editorUnnecessaryCode.opacity', { dark: Color.fromHex('#000a'), light: Color.fromHex('#0007'), hcDark: null, hcLight: null }, localize(652, 'Opacity of unnecessary (unused) source code in the editor. For example, "#000000c0" will render the code with 75% opacity. For high contrast themes, use the  \'editorUnnecessaryCode.border\' theme color to underline unnecessary code instead of fading it out.'));
-registerColor('editorGhostText.border', { dark: null, light: null, hcDark: Color.fromHex('#fff').transparent(0.8), hcLight: Color.fromHex('#292929').transparent(0.8) }, localize(653, 'Border color of ghost text in the editor.'));
-const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: Color.fromHex('#ffffff56'), light: Color.fromHex('#0007'), hcDark: null, hcLight: null }, localize(654, 'Foreground color of the ghost text in the editor.'));
-registerColor('editorGhostText.background', null, localize(655, 'Background color of the ghost text in the editor.'));
-const rulerRangeDefault = new Color(new RGBA(0, 122, 204, 0.6));
-const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', rulerRangeDefault, localize(656, 'Overview ruler marker color for range highlights. The color must not be opaque so as not to hide underlying decorations.'), true);
-const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { 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' }, localize(657, 'Overview ruler marker color for errors.'));
-const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, localize(658, 'Overview ruler marker color for warnings.'));
-const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, localize(659, 'Overview ruler marker color for infos.'));
-const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, localize(660, 'Foreground color of brackets (1). Requires enabling bracket pair colorization.'));
-const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, localize(661, 'Foreground color of brackets (2). Requires enabling bracket pair colorization.'));
-const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, localize(662, 'Foreground color of brackets (3). Requires enabling bracket pair colorization.'));
-const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', localize(663, 'Foreground color of brackets (4). Requires enabling bracket pair colorization.'));
-const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', localize(664, 'Foreground color of brackets (5). Requires enabling bracket pair colorization.'));
-const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', localize(665, 'Foreground color of brackets (6). Requires enabling bracket pair colorization.'));
-const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: new Color(new RGBA(255, 18, 18, 0.8)), light: new Color(new RGBA(255, 18, 18, 0.8)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '#B5200D' }, localize(666, 'Foreground color of unexpected brackets.'));
-const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', localize(667, 'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', localize(668, 'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', localize(669, 'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', localize(670, 'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', localize(671, 'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', localize(672, 'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', localize(673, 'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', localize(674, 'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', localize(675, 'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', localize(676, 'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', localize(677, 'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'));
-const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', localize(678, 'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'));
-registerColor('editorUnicodeHighlight.border', editorWarningForeground, localize(679, 'Border color used to highlight unicode characters.'));
-registerColor('editorUnicodeHighlight.background', editorWarningBackground, localize(680, 'Background color used to highlight unicode characters.'));
-// contains all color rules that used to defined in editor/browser/widget/editor.css
-registerThemingParticipant((theme, collector) => {
-    const background = theme.getColor(editorBackground);
-    const lineHighlight = theme.getColor(editorLineHighlight);
-    const imeBackground = (lineHighlight && !lineHighlight.isTransparent() ? lineHighlight : background);
-    if (imeBackground) {
-        collector.addRule(`.monaco-editor .inputarea.ime-input { background-color: ${imeBackground}; }`);
-    }
-});
-
-export { deprecatedEditorActiveIndentGuides, deprecatedEditorIndentGuides, editorActiveIndentGuide1, editorActiveIndentGuide2, editorActiveIndentGuide3, editorActiveIndentGuide4, editorActiveIndentGuide5, editorActiveIndentGuide6, editorBracketHighlightingForeground1, editorBracketHighlightingForeground2, editorBracketHighlightingForeground3, editorBracketHighlightingForeground4, editorBracketHighlightingForeground5, editorBracketHighlightingForeground6, editorBracketHighlightingUnexpectedBracketForeground, editorBracketPairGuideActiveBackground1, editorBracketPairGuideActiveBackground2, editorBracketPairGuideActiveBackground3, editorBracketPairGuideActiveBackground4, editorBracketPairGuideActiveBackground5, editorBracketPairGuideActiveBackground6, editorBracketPairGuideBackground1, editorBracketPairGuideBackground2, editorBracketPairGuideBackground3, editorBracketPairGuideBackground4, editorBracketPairGuideBackground5, editorBracketPairGuideBackground6, editorCursorBackground, editorCursorForeground, editorDimmedLineNumber, editorIndentGuide1, editorIndentGuide2, editorIndentGuide3, editorIndentGuide4, editorIndentGuide5, editorIndentGuide6, editorLineHighlight, editorLineHighlightBorder, editorLineNumbers, editorMultiCursorPrimaryBackground, editorMultiCursorPrimaryForeground, editorMultiCursorSecondaryBackground, editorMultiCursorSecondaryForeground, editorOverviewRulerBackground, editorOverviewRulerBorder, editorRuler, editorUnnecessaryCodeOpacity, editorWhitespaces, ghostTextForeground, overviewRulerError, overviewRulerInfo, overviewRulerRangeHighlight, overviewRulerWarning };

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

@@ -1,13 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * The type of the `IEditor`.
- */
-const EditorType = {
-    ICodeEditor: 'vs.editor.ICodeEditor',
-    IDiffEditor: 'vs.editor.IDiffEditor'
-};
-
-export { EditorType };

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

@@ -1,338 +0,0 @@
-import { diffEditorDefaultOptions } from './diffEditor.js';
-import { editorOptionsRegistry } from './editorOptions.js';
-import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
-import { localize } from '../../../nls.js';
-import { Extensions } from '../../../platform/configuration/common/configurationRegistry.js';
-import { Registry } from '../../../platform/registry/common/platform.js';
-
-const editorConfigurationBaseNode = Object.freeze({
-    id: 'editor',
-    order: 5,
-    type: 'object',
-    title: localize(147, "Editor"),
-    scope: 6 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
-});
-const editorConfiguration = {
-    ...editorConfigurationBaseNode,
-    properties: {
-        'editor.tabSize': {
-            type: 'number',
-            default: EDITOR_MODEL_DEFAULTS.tabSize,
-            minimum: 1,
-            maximum: 100,
-            markdownDescription: localize(148, "The number of spaces a tab is equal to. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
-        },
-        'editor.indentSize': {
-            'anyOf': [
-                {
-                    type: 'string',
-                    enum: ['tabSize']
-                },
-                {
-                    type: 'number',
-                    minimum: 1
-                }
-            ],
-            default: 'tabSize',
-            markdownDescription: localize(149, "The number of spaces used for indentation or `\"tabSize\"` to use the value from `#editor.tabSize#`. This setting is overridden based on the file contents when `#editor.detectIndentation#` is on.")
-        },
-        'editor.insertSpaces': {
-            type: 'boolean',
-            default: EDITOR_MODEL_DEFAULTS.insertSpaces,
-            markdownDescription: localize(150, "Insert spaces when pressing `Tab`. This setting is overridden based on the file contents when {0} is on.", '`#editor.detectIndentation#`')
-        },
-        'editor.detectIndentation': {
-            type: 'boolean',
-            default: EDITOR_MODEL_DEFAULTS.detectIndentation,
-            markdownDescription: localize(151, "Controls whether {0} and {1} will be automatically detected when a file is opened based on the file contents.", '`#editor.tabSize#`', '`#editor.insertSpaces#`')
-        },
-        'editor.trimAutoWhitespace': {
-            type: 'boolean',
-            default: EDITOR_MODEL_DEFAULTS.trimAutoWhitespace,
-            description: localize(152, "Remove trailing auto inserted whitespace.")
-        },
-        'editor.largeFileOptimizations': {
-            type: 'boolean',
-            default: EDITOR_MODEL_DEFAULTS.largeFileOptimizations,
-            description: localize(153, "Special handling for large files to disable certain memory intensive features.")
-        },
-        'editor.wordBasedSuggestions': {
-            enum: ['off', 'currentDocument', 'matchingDocuments', 'allDocuments'],
-            default: 'matchingDocuments',
-            enumDescriptions: [
-                localize(154, 'Turn off Word Based Suggestions.'),
-                localize(155, 'Only suggest words from the active document.'),
-                localize(156, 'Suggest words from all open documents of the same language.'),
-                localize(157, 'Suggest words from all open documents.')
-            ],
-            description: localize(158, "Controls whether completions should be computed based on words in the document and from which documents they are computed.")
-        },
-        'editor.semanticHighlighting.enabled': {
-            enum: [true, false, 'configuredByTheme'],
-            enumDescriptions: [
-                localize(159, 'Semantic highlighting enabled for all color themes.'),
-                localize(160, 'Semantic highlighting disabled for all color themes.'),
-                localize(161, 'Semantic highlighting is configured by the current color theme\'s `semanticHighlighting` setting.')
-            ],
-            default: 'configuredByTheme',
-            description: localize(162, "Controls whether the semanticHighlighting is shown for the languages that support it.")
-        },
-        'editor.stablePeek': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: localize(163, "Keep peek editors open even when double-clicking their content or when hitting `Escape`.")
-        },
-        'editor.maxTokenizationLineLength': {
-            type: 'integer',
-            default: 20_000,
-            description: localize(164, "Lines above this length will not be tokenized for performance reasons")
-        },
-        'editor.experimental.asyncTokenization': {
-            type: 'boolean',
-            default: true,
-            description: localize(165, "Controls whether the tokenization should happen asynchronously on a web worker."),
-            tags: ['experimental'],
-        },
-        'editor.experimental.asyncTokenizationLogging': {
-            type: 'boolean',
-            default: false,
-            description: localize(166, "Controls whether async tokenization should be logged. For debugging only."),
-        },
-        'editor.experimental.asyncTokenizationVerification': {
-            type: 'boolean',
-            default: false,
-            description: localize(167, "Controls whether async tokenization should be verified against legacy background tokenization. Might slow down tokenization. For debugging only."),
-            tags: ['experimental'],
-        },
-        'editor.experimental.treeSitterTelemetry': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: localize(168, "Controls whether tree sitter parsing should be turned on and telemetry collected. Setting `#editor.experimental.preferTreeSitter#` for specific languages will take precedence."),
-            tags: ['experimental'],
-            experiment: {
-                mode: 'auto'
-            }
-        },
-        'editor.experimental.preferTreeSitter.css': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: localize(169, "Controls whether tree sitter parsing should be turned on for css. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for css."),
-            tags: ['experimental'],
-            experiment: {
-                mode: 'auto'
-            }
-        },
-        'editor.experimental.preferTreeSitter.typescript': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: localize(170, "Controls whether tree sitter parsing should be turned on for typescript. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for typescript."),
-            tags: ['experimental'],
-            experiment: {
-                mode: 'auto'
-            }
-        },
-        'editor.experimental.preferTreeSitter.ini': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: localize(171, "Controls whether tree sitter parsing should be turned on for ini. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for ini."),
-            tags: ['experimental'],
-            experiment: {
-                mode: 'auto'
-            }
-        },
-        'editor.experimental.preferTreeSitter.regex': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: localize(172, "Controls whether tree sitter parsing should be turned on for regex. This will take precedence over `#editor.experimental.treeSitterTelemetry#` for regex."),
-            tags: ['experimental'],
-            experiment: {
-                mode: 'auto'
-            }
-        },
-        'editor.language.brackets': {
-            type: ['array', 'null'],
-            default: null, // We want to distinguish the empty array from not configured.
-            description: localize(173, 'Defines the bracket symbols that increase or decrease the indentation.'),
-            items: {
-                type: 'array',
-                items: [
-                    {
-                        type: 'string',
-                        description: localize(174, 'The opening bracket character or string sequence.')
-                    },
-                    {
-                        type: 'string',
-                        description: localize(175, 'The closing bracket character or string sequence.')
-                    }
-                ]
-            }
-        },
-        'editor.language.colorizedBracketPairs': {
-            type: ['array', 'null'],
-            default: null, // We want to distinguish the empty array from not configured.
-            description: localize(176, 'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'),
-            items: {
-                type: 'array',
-                items: [
-                    {
-                        type: 'string',
-                        description: localize(177, 'The opening bracket character or string sequence.')
-                    },
-                    {
-                        type: 'string',
-                        description: localize(178, 'The closing bracket character or string sequence.')
-                    }
-                ]
-            }
-        },
-        'diffEditor.maxComputationTime': {
-            type: 'number',
-            default: diffEditorDefaultOptions.maxComputationTime,
-            description: localize(179, "Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.")
-        },
-        'diffEditor.maxFileSize': {
-            type: 'number',
-            default: diffEditorDefaultOptions.maxFileSize,
-            description: localize(180, "Maximum file size in MB for which to compute diffs. Use 0 for no limit.")
-        },
-        'diffEditor.renderSideBySide': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.renderSideBySide,
-            description: localize(181, "Controls whether the diff editor shows the diff side by side or inline.")
-        },
-        'diffEditor.renderSideBySideInlineBreakpoint': {
-            type: 'number',
-            default: diffEditorDefaultOptions.renderSideBySideInlineBreakpoint,
-            description: localize(182, "If the diff editor width is smaller than this value, the inline view is used.")
-        },
-        'diffEditor.useInlineViewWhenSpaceIsLimited': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.useInlineViewWhenSpaceIsLimited,
-            description: localize(183, "If enabled and the editor width is too small, the inline view is used.")
-        },
-        'diffEditor.renderMarginRevertIcon': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.renderMarginRevertIcon,
-            description: localize(184, "When enabled, the diff editor shows arrows in its glyph margin to revert changes.")
-        },
-        'diffEditor.renderGutterMenu': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.renderGutterMenu,
-            description: localize(185, "When enabled, the diff editor shows a special gutter for revert and stage actions.")
-        },
-        'diffEditor.ignoreTrimWhitespace': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.ignoreTrimWhitespace,
-            description: localize(186, "When enabled, the diff editor ignores changes in leading or trailing whitespace.")
-        },
-        'diffEditor.renderIndicators': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.renderIndicators,
-            description: localize(187, "Controls whether the diff editor shows +/- indicators for added/removed changes.")
-        },
-        'diffEditor.codeLens': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.diffCodeLens,
-            description: localize(188, "Controls whether the editor shows CodeLens.")
-        },
-        'diffEditor.wordWrap': {
-            type: 'string',
-            enum: ['off', 'on', 'inherit'],
-            default: diffEditorDefaultOptions.diffWordWrap,
-            markdownEnumDescriptions: [
-                localize(189, "Lines will never wrap."),
-                localize(190, "Lines will wrap at the viewport width."),
-                localize(191, "Lines will wrap according to the {0} setting.", '`#editor.wordWrap#`'),
-            ]
-        },
-        'diffEditor.diffAlgorithm': {
-            type: 'string',
-            enum: ['legacy', 'advanced'],
-            default: diffEditorDefaultOptions.diffAlgorithm,
-            markdownEnumDescriptions: [
-                localize(192, "Uses the legacy diffing algorithm."),
-                localize(193, "Uses the advanced diffing algorithm."),
-            ]
-        },
-        'diffEditor.hideUnchangedRegions.enabled': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.hideUnchangedRegions.enabled,
-            markdownDescription: localize(194, "Controls whether the diff editor shows unchanged regions."),
-        },
-        'diffEditor.hideUnchangedRegions.revealLineCount': {
-            type: 'integer',
-            default: diffEditorDefaultOptions.hideUnchangedRegions.revealLineCount,
-            markdownDescription: localize(195, "Controls how many lines are used for unchanged regions."),
-            minimum: 1,
-        },
-        'diffEditor.hideUnchangedRegions.minimumLineCount': {
-            type: 'integer',
-            default: diffEditorDefaultOptions.hideUnchangedRegions.minimumLineCount,
-            markdownDescription: localize(196, "Controls how many lines are used as a minimum for unchanged regions."),
-            minimum: 1,
-        },
-        'diffEditor.hideUnchangedRegions.contextLineCount': {
-            type: 'integer',
-            default: diffEditorDefaultOptions.hideUnchangedRegions.contextLineCount,
-            markdownDescription: localize(197, "Controls how many lines are used as context when comparing unchanged regions."),
-            minimum: 1,
-        },
-        'diffEditor.experimental.showMoves': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.experimental.showMoves,
-            markdownDescription: localize(198, "Controls whether the diff editor should show detected code moves.")
-        },
-        'diffEditor.experimental.showEmptyDecorations': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.experimental.showEmptyDecorations,
-            description: localize(199, "Controls whether the diff editor shows empty decorations to see where characters got inserted or deleted."),
-        },
-        'diffEditor.experimental.useTrueInlineView': {
-            type: 'boolean',
-            default: diffEditorDefaultOptions.experimental.useTrueInlineView,
-            description: localize(200, "If enabled and the editor uses the inline view, word changes are rendered inline."),
-        },
-    }
-};
-function isConfigurationPropertySchema(x) {
-    return (typeof x.type !== 'undefined' || typeof x.anyOf !== 'undefined');
-}
-// Add properties from the Editor Option Registry
-for (const editorOption of editorOptionsRegistry) {
-    const schema = editorOption.schema;
-    if (typeof schema !== 'undefined') {
-        if (isConfigurationPropertySchema(schema)) {
-            // This is a single schema contribution
-            editorConfiguration.properties[`editor.${editorOption.name}`] = schema;
-        }
-        else {
-            for (const key in schema) {
-                if (Object.hasOwnProperty.call(schema, key)) {
-                    editorConfiguration.properties[key] = schema[key];
-                }
-            }
-        }
-    }
-}
-let cachedEditorConfigurationKeys = null;
-function getEditorConfigurationKeys() {
-    if (cachedEditorConfigurationKeys === null) {
-        cachedEditorConfigurationKeys = Object.create(null);
-        Object.keys(editorConfiguration.properties).forEach((prop) => {
-            cachedEditorConfigurationKeys[prop] = true;
-        });
-    }
-    return cachedEditorConfigurationKeys;
-}
-function isEditorConfigurationKey(key) {
-    const editorConfigurationKeys = getEditorConfigurationKeys();
-    return (editorConfigurationKeys[`editor.${key}`] || false);
-}
-function isDiffEditorConfigurationKey(key) {
-    const editorConfigurationKeys = getEditorConfigurationKeys();
-    return (editorConfigurationKeys[`diffEditor.${key}`] || false);
-}
-const configurationRegistry = Registry.as(Extensions.Configuration);
-configurationRegistry.registerConfiguration(editorConfiguration);
-
-export { editorConfigurationBaseNode, isDiffEditorConfigurationKey, isEditorConfigurationKey };

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

@@ -1,84 +0,0 @@
-import { localize } from '../../nls.js';
-import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var EditorContextKeys;
-(function (EditorContextKeys) {
-    EditorContextKeys.editorSimpleInput = new RawContextKey('editorSimpleInput', false, true);
-    /**
-     * A context key that is set when the editor's text has focus (cursor is blinking).
-     * Is false when focus is in simple editor widgets (repl input, scm commit input).
-     */
-    EditorContextKeys.editorTextFocus = new RawContextKey('editorTextFocus', false, localize(681, "Whether the editor text has focus (cursor is blinking)"));
-    /**
-     * A context key that is set when the editor's text or an editor's widget has focus.
-     */
-    EditorContextKeys.focus = new RawContextKey('editorFocus', false, localize(682, "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"));
-    /**
-     * A context key that is set when any editor input has focus (regular editor, repl input...).
-     */
-    EditorContextKeys.textInputFocus = new RawContextKey('textInputFocus', false, localize(683, "Whether an editor or a rich text input has focus (cursor is blinking)"));
-    EditorContextKeys.readOnly = new RawContextKey('editorReadonly', false, localize(684, "Whether the editor is read-only"));
-    EditorContextKeys.inDiffEditor = new RawContextKey('inDiffEditor', false, localize(685, "Whether the context is a diff editor"));
-    EditorContextKeys.isEmbeddedDiffEditor = new RawContextKey('isEmbeddedDiffEditor', false, localize(686, "Whether the context is an embedded diff editor"));
-    EditorContextKeys.inMultiDiffEditor = new RawContextKey('inMultiDiffEditor', false, localize(687, "Whether the context is a multi diff editor"));
-    EditorContextKeys.multiDiffEditorAllCollapsed = new RawContextKey('multiDiffEditorAllCollapsed', undefined, localize(688, "Whether all files in multi diff editor are collapsed"));
-    EditorContextKeys.hasChanges = new RawContextKey('diffEditorHasChanges', false, localize(689, "Whether the diff editor has changes"));
-    EditorContextKeys.comparingMovedCode = new RawContextKey('comparingMovedCode', false, localize(690, "Whether a moved code block is selected for comparison"));
-    EditorContextKeys.accessibleDiffViewerVisible = new RawContextKey('accessibleDiffViewerVisible', false, localize(691, "Whether the accessible diff viewer is visible"));
-    EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, localize(692, "Whether the diff editor render side by side inline breakpoint is reached"));
-    EditorContextKeys.diffEditorInlineMode = new RawContextKey('diffEditorInlineMode', false, localize(693, "Whether inline mode is active"));
-    EditorContextKeys.diffEditorOriginalWritable = new RawContextKey('diffEditorOriginalWritable', false, localize(694, "Whether modified is writable in the diff editor"));
-    EditorContextKeys.diffEditorModifiedWritable = new RawContextKey('diffEditorModifiedWritable', false, localize(695, "Whether modified is writable in the diff editor"));
-    EditorContextKeys.diffEditorOriginalUri = new RawContextKey('diffEditorOriginalUri', '', localize(696, "The uri of the original document"));
-    EditorContextKeys.diffEditorModifiedUri = new RawContextKey('diffEditorModifiedUri', '', localize(697, "The uri of the modified document"));
-    EditorContextKeys.columnSelection = new RawContextKey('editorColumnSelection', false, localize(698, "Whether `editor.columnSelection` is enabled"));
-    EditorContextKeys.writable = EditorContextKeys.readOnly.toNegated();
-    EditorContextKeys.hasNonEmptySelection = new RawContextKey('editorHasSelection', false, localize(699, "Whether the editor has text selected"));
-    EditorContextKeys.hasOnlyEmptySelection = EditorContextKeys.hasNonEmptySelection.toNegated();
-    EditorContextKeys.hasMultipleSelections = new RawContextKey('editorHasMultipleSelections', false, localize(700, "Whether the editor has multiple selections"));
-    EditorContextKeys.hasSingleSelection = EditorContextKeys.hasMultipleSelections.toNegated();
-    EditorContextKeys.tabMovesFocus = new RawContextKey('editorTabMovesFocus', false, localize(701, "Whether `Tab` will move focus out of the editor"));
-    EditorContextKeys.tabDoesNotMoveFocus = EditorContextKeys.tabMovesFocus.toNegated();
-    EditorContextKeys.isInEmbeddedEditor = new RawContextKey('isInEmbeddedEditor', false, true);
-    EditorContextKeys.canUndo = new RawContextKey('canUndo', false, true);
-    EditorContextKeys.canRedo = new RawContextKey('canRedo', false, true);
-    EditorContextKeys.hoverVisible = new RawContextKey('editorHoverVisible', false, localize(702, "Whether the editor hover is visible"));
-    EditorContextKeys.hoverFocused = new RawContextKey('editorHoverFocused', false, localize(703, "Whether the editor hover is focused"));
-    EditorContextKeys.stickyScrollFocused = new RawContextKey('stickyScrollFocused', false, localize(704, "Whether the sticky scroll is focused"));
-    EditorContextKeys.stickyScrollVisible = new RawContextKey('stickyScrollVisible', false, localize(705, "Whether the sticky scroll is visible"));
-    EditorContextKeys.standaloneColorPickerVisible = new RawContextKey('standaloneColorPickerVisible', false, localize(706, "Whether the standalone color picker is visible"));
-    EditorContextKeys.standaloneColorPickerFocused = new RawContextKey('standaloneColorPickerFocused', false, localize(707, "Whether the standalone color picker is focused"));
-    /**
-     * A context key that is set when an editor is part of a larger editor, like notebooks or
-     * (future) a diff editor
-     */
-    EditorContextKeys.inCompositeEditor = new RawContextKey('inCompositeEditor', undefined, localize(708, "Whether the editor is part of a larger editor (e.g. notebooks)"));
-    EditorContextKeys.notInCompositeEditor = EditorContextKeys.inCompositeEditor.toNegated();
-    // -- mode context keys
-    EditorContextKeys.languageId = new RawContextKey('editorLangId', '', localize(709, "The language identifier of the editor"));
-    EditorContextKeys.hasCompletionItemProvider = new RawContextKey('editorHasCompletionItemProvider', false, localize(710, "Whether the editor has a completion item provider"));
-    EditorContextKeys.hasCodeActionsProvider = new RawContextKey('editorHasCodeActionsProvider', false, localize(711, "Whether the editor has a code actions provider"));
-    EditorContextKeys.hasCodeLensProvider = new RawContextKey('editorHasCodeLensProvider', false, localize(712, "Whether the editor has a code lens provider"));
-    EditorContextKeys.hasDefinitionProvider = new RawContextKey('editorHasDefinitionProvider', false, localize(713, "Whether the editor has a definition provider"));
-    EditorContextKeys.hasDeclarationProvider = new RawContextKey('editorHasDeclarationProvider', false, localize(714, "Whether the editor has a declaration provider"));
-    EditorContextKeys.hasImplementationProvider = new RawContextKey('editorHasImplementationProvider', false, localize(715, "Whether the editor has an implementation provider"));
-    EditorContextKeys.hasTypeDefinitionProvider = new RawContextKey('editorHasTypeDefinitionProvider', false, localize(716, "Whether the editor has a type definition provider"));
-    EditorContextKeys.hasHoverProvider = new RawContextKey('editorHasHoverProvider', false, localize(717, "Whether the editor has a hover provider"));
-    EditorContextKeys.hasDocumentHighlightProvider = new RawContextKey('editorHasDocumentHighlightProvider', false, localize(718, "Whether the editor has a document highlight provider"));
-    EditorContextKeys.hasDocumentSymbolProvider = new RawContextKey('editorHasDocumentSymbolProvider', false, localize(719, "Whether the editor has a document symbol provider"));
-    EditorContextKeys.hasReferenceProvider = new RawContextKey('editorHasReferenceProvider', false, localize(720, "Whether the editor has a reference provider"));
-    EditorContextKeys.hasRenameProvider = new RawContextKey('editorHasRenameProvider', false, localize(721, "Whether the editor has a rename provider"));
-    EditorContextKeys.hasSignatureHelpProvider = new RawContextKey('editorHasSignatureHelpProvider', false, localize(722, "Whether the editor has a signature help provider"));
-    EditorContextKeys.hasInlayHintsProvider = new RawContextKey('editorHasInlayHintsProvider', false, localize(723, "Whether the editor has an inline hints provider"));
-    // -- mode context keys: formatting
-    EditorContextKeys.hasDocumentFormattingProvider = new RawContextKey('editorHasDocumentFormattingProvider', false, localize(724, "Whether the editor has a document formatting provider"));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, localize(725, "Whether the editor has a document selection formatting provider"));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, localize(726, "Whether the editor has multiple document formatting providers"));
-    EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = new RawContextKey('editorHasMultipleDocumentSelectionFormattingProvider', false, localize(727, "Whether the editor has multiple document selection formatting providers"));
-})(EditorContextKeys || (EditorContextKeys = {}));
-
-export { EditorContextKeys };

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

@@ -1,17 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const editorFeatures = [];
-/**
- * Registers an editor feature. Editor features will be instantiated only once, as soon as
- * the first code editor is instantiated.
- */
-function registerEditorFeature(ctor) {
-    editorFeatures.push(ctor);
-}
-function getEditorFeatures() {
-    return editorFeatures.slice(0);
-}
-
-export { getEditorFeatures, registerEditorFeature };