monaco-editor11 1.0.7 → 1.0.9

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

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

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

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

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

@@ -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.
+ *--------------------------------------------------------------------------------------------*/
+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 };