visualstudiocode.info
Filter
Filters: 
Edit

b

breadcrumbs

Enable/disable navigation breadcrumbs.

Controls whether and how file paths are shown in the breadcrumbs view.
- on: Show the file path in the breadcrumbs view.
- off: Do not show the file path in the breadcrumbs view.
- last: Only show the last element of the file path in the breadcrumbs view.

Render breadcrumb items with icons.

When enabled breadcrumbs show array-symbols.

When enabled breadcrumbs show boolean-symbols.

When enabled breadcrumbs show class-symbols.

When enabled breadcrumbs show constant-symbols.

When enabled breadcrumbs show constructor-symbols.

When enabled breadcrumbs show enumMember-symbols.

When enabled breadcrumbs show enum-symbols.

When enabled breadcrumbs show event-symbols.

When enabled breadcrumbs show field-symbols.

When enabled breadcrumbs show file-symbols.

When enabled breadcrumbs show function-symbols.

When enabled breadcrumbs show interface-symbols.

When enabled breadcrumbs show key-symbols.

When enabled breadcrumbs show method-symbols.

When enabled breadcrumbs show module-symbols.

When enabled breadcrumbs show namespace-symbols.

When enabled breadcrumbs show null-symbols.

When enabled breadcrumbs show number-symbols.

When enabled breadcrumbs show object-symbols.

When enabled breadcrumbs show operator-symbols.

When enabled breadcrumbs show package-symbols.

When enabled breadcrumbs show property-symbols.

When enabled breadcrumbs show string-symbols.

When enabled breadcrumbs show struct-symbols.

When enabled breadcrumbs show typeParameter-symbols.

When enabled breadcrumbs show variable-symbols.

Controls whether and how symbols are shown in the breadcrumbs view.
- on: Show all symbols in the breadcrumbs view.
- off: Do not show symbols in the breadcrumbs view.
- last: Only show the current symbol in the breadcrumbs view.

Controls how symbols are sorted in the breadcrumbs outline view.
- position: Show symbol outline in file position order.
- name: Show symbol outline in alphabetical order.
- type: Show symbol outline in symbol type order.

c

comments
comments.openPanel

    Controls when the comments panel should open.

    css
    css.completion.completePropertyWithSemicolon

      Insert semicolon at end of line when completing CSS properties.

      css.completion.triggerPropertyValueCompletion

        By default, VS Code triggers property value completion after selecting a CSS property. Use this setting to disable this behavior.

        css.customData

          A list of relative file paths pointing to JSON files following the custom data format.

          VS Code loads custom data on startup to enhance its CSS support for the custom CSS properties, at directives, pseudo classes and pseudo elements you specify in the JSON files.

          The file paths are relative to workspace and only workspace folder settings are considered.

          css.hover.documentation

            Show tag and attribute documentation in CSS hovers.

            css.hover.references

              Show references to MDN in CSS hovers.

              css.lint.argumentsInColorFunction

                Invalid number of parameters.

                css.lint.boxModel

                  Do not use width or height when using padding or border.

                  css.lint.compatibleVendorPrefixes

                    When using a vendor-specific prefix make sure to also include all other vendor-specific properties.

                    css.lint.duplicateProperties

                      Do not use duplicate style definitions.

                      css.lint.emptyRules

                        Do not use empty rulesets.

                        css.lint.float

                          Avoid using float. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes.

                          css.lint.fontFaceProperties

                            @font-face rule must define src and font-family properties.

                            css.lint.hexColorLength

                              Hex colors must consist of three or six hex numbers.

                              css.lint.idSelector

                                Selectors should not contain IDs because these rules are too tightly coupled with the HTML.

                                css.lint.ieHack

                                  IE hacks are only necessary when supporting IE7 and older.

                                  css.lint.important

                                    Avoid using !important. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored.

                                    css.lint.importStatement

                                      Import statements do not load in parallel.

                                      css.lint.propertyIgnoredDueToDisplay

                                        Property is ignored due to the display. E.g. with display: inline, the width, height, margin-top, margin-bottom, and float properties have no effect.

                                        css.lint.universalSelector

                                          The universal selector (*) is known to be slow.

                                          css.lint.unknownAtRules

                                            Unknown at-rule.

                                            css.lint.unknownProperties

                                              Unknown property.

                                              css.lint.unknownVendorSpecificProperties

                                                Unknown vendor specific property.

                                                css.lint.validProperties

                                                  A list of properties that are not validated against the unknownProperties rule.

                                                  css.lint.vendorPrefix

                                                    When using a vendor-specific prefix, also include the standard property.

                                                    css.lint.zeroUnits

                                                      No unit for zero needed.

                                                      css.trace.server

                                                        Traces the communication between VS Code and the CSS language server.

                                                        css.validate

                                                          Enables or disables all validations.

                                                          [css]
                                                          [css]

                                                            Configure settings to be overridden for [css] language.

                                                            d

                                                            debug
                                                            debug.allowBreakpointsEverywhere

                                                              Allow setting breakpoints in any file.

                                                              debug.confirmOnExit

                                                                Controls whether to confirm when the window closes if there are active debug sessions.
                                                                - never: Never confirm.
                                                                - always: Always confirm if there are debug sessions.

                                                                debug.console.acceptSuggestionOnEnter

                                                                  Controls whether suggestions should be accepted on enter in the debug console. enter is also used to evaluate whatever is typed in the debug console.

                                                                  debug.console.closeOnEnd

                                                                    Controls if the debug console should be automatically closed when the debug session ends.

                                                                    debug.console.collapseIdenticalLines

                                                                      Controls if the debug console should collapse identical lines and show a number of occurrences with a badge.

                                                                      debug.console.fontFamily

                                                                        Controls the font family in the debug console.

                                                                        debug.console.fontSize

                                                                          Controls the font size in pixels in the debug console.

                                                                          debug.console.historySuggestions

                                                                            Controls if the debug console should suggest previously typed input.

                                                                            debug.console.lineHeight

                                                                              Controls the line height in pixels in the debug console. Use 0 to compute the line height from the font size.

                                                                              debug.console.wordWrap

                                                                                Controls if the lines should wrap in the debug console.

                                                                                debug.focusWindowOnBreak

                                                                                  Controls whether the workbench window should be focused when the debugger breaks.

                                                                                  debug.inlineValues

                                                                                    Show variable values inline in editor while debugging.
                                                                                    - true: Always show variable values inline in editor while debugging.
                                                                                    - false: Never show variable values inline in editor while debugging.
                                                                                    - auto: Show variable values inline in editor while debugging when the language supports inline value locations.

                                                                                    debug.internalConsoleOptions

                                                                                      Controls when the internal debug console should open.

                                                                                      debug.javascript.autoAttachFilter

                                                                                        Configures which processes to automatically attach and debug when debug.node.autoAttach is on. A Node process launched with the --inspect flag will always be attached to, regardless of this setting.
                                                                                        - always: Auto attach to every Node.js process launched in the terminal.
                                                                                        - smart: Auto attach when running scripts that aren't in a node_modules folder.
                                                                                        - onlyWithFlag: Only auto attach when the --inspect is given.
                                                                                        - disabled: Auto attach is disabled and not shown in status bar.

                                                                                        debug.javascript.autoAttachSmartPattern

                                                                                          Configures glob patterns for determining when to attach in "smart" debug.javascript.autoAttachFilter mode. $KNOWN_TOOLS$ is replaced with a list of names of common test and code runners. Read more on the VS Code docs.

                                                                                          debug.javascript.autoExpandGetters

                                                                                            Configures whether property getters will be expanded automatically. If this is false, the getter will appear as get propertyName and will only be evaluated when you click on it.

                                                                                            debug.javascript.automaticallyTunnelRemoteServer

                                                                                              When debugging a remote web app, configures whether to automatically tunnel the remote server to your local machine.

                                                                                              debug.javascript.breakOnConditionalError

                                                                                                Whether to stop when conditional breakpoints throw an error.

                                                                                                debug.javascript.codelens.npmScripts

                                                                                                  Where a "Run" and "Debug" code lens should be shown in your npm scripts. It may be on "all", scripts, on "top" of the script section, or "never".

                                                                                                  debug.javascript.debugByLinkOptions

                                                                                                    Options used when debugging open links clicked from inside the JavaScript Debug Terminal. Can be set to "off" to disable this behavior, or "always" to enable debugging in all terminals.

                                                                                                    debug.javascript.defaultRuntimeExecutable

                                                                                                      The default runtimeExecutable used for launch configurations, if unspecified. This can be used to config custom paths to Node.js or browser installations.

                                                                                                      debug.javascript.pickAndAttachOptions

                                                                                                        Default options used when debugging a process through the Debug: Attach to Node.js Process command

                                                                                                        debug.javascript.resourceRequestOptions

                                                                                                          Request options to use when loading resources, such as source maps, in the debugger. You may need to configure this if your sourcemaps require authentication or use a self-signed certificate, for instance. Options are used to create a request using the got library.

                                                                                                          A common case to disable certificate verification can be done by passing { "https": { "rejectUnauthorized": false } }.

                                                                                                          debug.javascript.suggestPrettyPrinting

                                                                                                            Whether to suggest pretty printing JavaScript code that looks minified when you step into it.

                                                                                                            debug.javascript.terminalOptions

                                                                                                              Default launch options for the JavaScript debug terminal and npm scripts.

                                                                                                              debug.javascript.unmapMissingSources

                                                                                                                Configures whether sourcemapped file where the original file can't be read will automatically be unmapped. If this is false (default), a prompt is shown.

                                                                                                                debug.onTaskErrors

                                                                                                                  Controls what to do when errors are encountered after running a preLaunchTask.
                                                                                                                  - debugAnyway: Ignore task errors and start debugging.
                                                                                                                  - showErrors: Show the Problems view and do not start debugging.
                                                                                                                  - prompt: Prompt user.
                                                                                                                  - abort: Cancel debugging.

                                                                                                                  debug.openDebug

                                                                                                                    Controls when the debug view should open.

                                                                                                                    debug.openExplorerOnEnd

                                                                                                                      Automatically open the explorer view at the end of a debug session.

                                                                                                                      debug.saveBeforeStart

                                                                                                                        Controls what editors to save before starting a debug session.
                                                                                                                        - allEditorsInActiveGroup: Save all editors in the active group before starting a debug session.
                                                                                                                        - nonUntitledEditorsInActiveGroup: Save all editors in the active group except untitled ones before starting a debug session.
                                                                                                                        - none: Don't save any editors before starting a debug session.

                                                                                                                        debug.showBreakpointsInOverviewRuler

                                                                                                                          Controls whether breakpoints should be shown in the overview ruler.

                                                                                                                          debug.showInlineBreakpointCandidates

                                                                                                                            Controls whether inline breakpoints candidate decorations should be shown in the editor while debugging.

                                                                                                                            debug.showInStatusBar

                                                                                                                              Controls when the debug status bar should be visible.
                                                                                                                              - never: Never show debug in status bar
                                                                                                                              - always: Always show debug in status bar
                                                                                                                              - onFirstSessionStart: Show debug in status bar only after debug was started for the first time

                                                                                                                              debug.showSubSessionsInToolBar

                                                                                                                                Controls whether the debug sub-sessions are shown in the debug tool bar. When this setting is false the stop command on a sub-session will also stop the parent session.

                                                                                                                                debug.terminal.clearBeforeReusing

                                                                                                                                  Before starting a new debug session in an integrated or external terminal, clear the terminal.

                                                                                                                                  debug.toolBarLocation

                                                                                                                                    Controls the location of the debug toolbar. Either floating in all views, docked in the debug view, or hidden.

                                                                                                                                    diffEditor
                                                                                                                                    diffEditor.codeLens

                                                                                                                                      Controls whether the editor shows CodeLens.

                                                                                                                                      diffEditor.ignoreTrimWhitespace

                                                                                                                                        When enabled, the diff editor ignores changes in leading or trailing whitespace.

                                                                                                                                        diffEditor.maxComputationTime

                                                                                                                                          Timeout in milliseconds after which diff computation is cancelled. Use 0 for no timeout.

                                                                                                                                          diffEditor.renderIndicators

                                                                                                                                            Controls whether the diff editor shows +/- indicators for added/removed changes.

                                                                                                                                            diffEditor.renderSideBySide

                                                                                                                                              Controls whether the diff editor shows the diff side by side or inline.

                                                                                                                                              diffEditor.wordWrap

                                                                                                                                                - off: Lines will never wrap.
                                                                                                                                                - on: Lines will wrap at the viewport width.
                                                                                                                                                - inherit: Lines will wrap according to the editor.wordWrap setting.

                                                                                                                                                [dockercompose]
                                                                                                                                                [dockercompose]

                                                                                                                                                  Configure settings to be overridden for [dockercompose] language.

                                                                                                                                                  [dockerfile]
                                                                                                                                                  [dockerfile]

                                                                                                                                                    Configure settings to be overridden for [dockerfile] language.

                                                                                                                                                    e

                                                                                                                                                    editor
                                                                                                                                                    editor.acceptSuggestionOnCommitCharacter

                                                                                                                                                      Controls whether suggestions should be accepted on commit characters. For example, in JavaScript, the semi-colon (;) can be a commit character that accepts a suggestion and types that character.

                                                                                                                                                      editor.acceptSuggestionOnEnter

                                                                                                                                                        Controls whether suggestions should be accepted on Enter, in addition to Tab. Helps to avoid ambiguity between inserting new lines or accepting suggestions.
                                                                                                                                                        - on
                                                                                                                                                        - smart: Only accept a suggestion with Enter when it makes a textual change.
                                                                                                                                                        - off

                                                                                                                                                        editor.accessibilityPageSize

                                                                                                                                                          Controls the number of lines in the editor that can be read out by a screen reader at once. When we detect a screen reader we automatically set the default to be 500. Warning: this has a performance implication for numbers larger than the default.

                                                                                                                                                          editor.accessibilitySupport

                                                                                                                                                            Controls whether the editor should run in a mode where it is optimized for screen readers. Setting to on will disable word wrapping.
                                                                                                                                                            - auto: The editor will use platform APIs to detect when a Screen Reader is attached.
                                                                                                                                                            - on: The editor will be permanently optimized for usage with a Screen Reader. Word wrapping will be disabled.
                                                                                                                                                            - off: The editor will never be optimized for usage with a Screen Reader.

                                                                                                                                                            editor.autoClosingBrackets

                                                                                                                                                              Controls whether the editor should automatically close brackets after the user adds an opening bracket.
                                                                                                                                                              - always
                                                                                                                                                              - languageDefined: Use language configurations to determine when to autoclose brackets.
                                                                                                                                                              - beforeWhitespace: Autoclose brackets only when the cursor is to the left of whitespace.
                                                                                                                                                              - never

                                                                                                                                                              editor.autoClosingDelete

                                                                                                                                                                Controls whether the editor should remove adjacent closing quotes or brackets when deleting.
                                                                                                                                                                - always
                                                                                                                                                                - auto: Remove adjacent closing quotes or brackets only if they were automatically inserted.
                                                                                                                                                                - never

                                                                                                                                                                editor.autoClosingOvertype

                                                                                                                                                                  Controls whether the editor should type over closing quotes or brackets.
                                                                                                                                                                  - always
                                                                                                                                                                  - auto: Type over closing quotes or brackets only if they were automatically inserted.
                                                                                                                                                                  - never

                                                                                                                                                                  editor.autoClosingQuotes

                                                                                                                                                                    Controls whether the editor should automatically close quotes after the user adds an opening quote.
                                                                                                                                                                    - always
                                                                                                                                                                    - languageDefined: Use language configurations to determine when to autoclose quotes.
                                                                                                                                                                    - beforeWhitespace: Autoclose quotes only when the cursor is to the left of whitespace.
                                                                                                                                                                    - never

                                                                                                                                                                    editor.autoIndent

                                                                                                                                                                      Controls whether the editor should automatically adjust the indentation when users type, paste, move or indent lines.
                                                                                                                                                                      - none: The editor will not insert indentation automatically.
                                                                                                                                                                      - keep: The editor will keep the current line's indentation.
                                                                                                                                                                      - brackets: The editor will keep the current line's indentation and honor language defined brackets.
                                                                                                                                                                      - advanced: The editor will keep the current line's indentation, honor language defined brackets and invoke special onEnterRules defined by languages.
                                                                                                                                                                      - full: The editor will keep the current line's indentation, honor language defined brackets, invoke special onEnterRules defined by languages, and honor indentationRules defined by languages.

                                                                                                                                                                      editor.autoSurround

                                                                                                                                                                        Controls whether the editor should automatically surround selections when typing quotes or brackets.
                                                                                                                                                                        - languageDefined: Use language configurations to determine when to automatically surround selections.
                                                                                                                                                                        - quotes: Surround with quotes but not brackets.
                                                                                                                                                                        - brackets: Surround with brackets but not quotes.
                                                                                                                                                                        - never

                                                                                                                                                                        editor.bracketPairColorization.enabled

                                                                                                                                                                          Controls whether bracket pair colorization is enabled or not. Use 'workbench.colorCustomizations' to override the bracket highlight colors.

                                                                                                                                                                          editor.codeActionsOnSave

                                                                                                                                                                            Code action kinds to be run on save.

                                                                                                                                                                            editor.codeLens

                                                                                                                                                                              Controls whether the editor shows CodeLens.

                                                                                                                                                                              editor.codeLensFontFamily

                                                                                                                                                                                Controls the font family for CodeLens.

                                                                                                                                                                                editor.codeLensFontSize

                                                                                                                                                                                  Controls the font size in pixels for CodeLens. When set to 0, the 90% of editor.fontSize is used.

                                                                                                                                                                                  editor.colorDecorators

                                                                                                                                                                                    Controls whether the editor should render the inline color decorators and color picker.

                                                                                                                                                                                    editor.columnSelection

                                                                                                                                                                                      Enable that the selection with the mouse and keys is doing column selection.

                                                                                                                                                                                      editor.comments.ignoreEmptyLines

                                                                                                                                                                                        Controls if empty lines should be ignored with toggle, add or remove actions for line comments.

                                                                                                                                                                                        editor.comments.insertSpace

                                                                                                                                                                                          Controls whether a space character is inserted when commenting.

                                                                                                                                                                                          editor.copyWithSyntaxHighlighting

                                                                                                                                                                                            Controls whether syntax highlighting should be copied into the clipboard.

                                                                                                                                                                                            editor.cursorBlinking

                                                                                                                                                                                              Control the cursor animation style.

                                                                                                                                                                                              editor.cursorSmoothCaretAnimation

                                                                                                                                                                                                Controls whether the smooth caret animation should be enabled.

                                                                                                                                                                                                editor.cursorStyle

                                                                                                                                                                                                  Controls the cursor style.

                                                                                                                                                                                                  editor.cursorSurroundingLines

                                                                                                                                                                                                    Controls the minimal number of visible leading and trailing lines surrounding the cursor. Known as 'scrollOff' or 'scrollOffset' in some other editors.

                                                                                                                                                                                                    editor.cursorSurroundingLinesStyle

                                                                                                                                                                                                      Controls when cursorSurroundingLines should be enforced.
                                                                                                                                                                                                      - default: cursorSurroundingLines is enforced only when triggered via the keyboard or API.
                                                                                                                                                                                                      - all: cursorSurroundingLines is enforced always.

                                                                                                                                                                                                      editor.cursorWidth

                                                                                                                                                                                                        Controls the width of the cursor when editor.cursorStyle is set to line.

                                                                                                                                                                                                        editor.defaultFormatter

                                                                                                                                                                                                          Defines a default formatter which takes precedence over all other formatter settings. Must be the identifier of an extension contributing a formatter.
                                                                                                                                                                                                          - null: None
                                                                                                                                                                                                          - vscode.css-language-features: Provides rich language support for CSS, LESS and SCSS files.
                                                                                                                                                                                                          - vscode.html-language-features: Provides rich language support for HTML and Handlebar files
                                                                                                                                                                                                          - vscode.json-language-features: Provides rich language support for JSON files.
                                                                                                                                                                                                          - vscode.markdown-language-features: Provides rich language support for Markdown.
                                                                                                                                                                                                          - vscode.php-language-features: Provides rich language support for PHP files.
                                                                                                                                                                                                          - ms-vscode.references-view: Reference Search results as separate, stable view in the sidebar
                                                                                                                                                                                                          - vscode.search-result: Provides syntax highlighting and language features for tabbed search results.
                                                                                                                                                                                                          - vscode.typescript-language-features: Provides rich language support for JavaScript and TypeScript.
                                                                                                                                                                                                          - vscode.configuration-editing: Provides capabilities (advanced IntelliSense, auto-fixing) in configuration files like settings, launch, and extension recommendation files.
                                                                                                                                                                                                          - vscode.debug-auto-launch: Helper for auto-attach feature when node-debug extensions are not active.
                                                                                                                                                                                                          - vscode.debug-server-ready: Open URI in browser if server under debugging is ready.
                                                                                                                                                                                                          - vscode.emmet: Emmet support for VS Code
                                                                                                                                                                                                          - vscode.extension-editing: Provides linting capabilities for authoring extensions.
                                                                                                                                                                                                          - vscode.git: Git SCM Integration
                                                                                                                                                                                                          - vscode.github: GitHub features for VS Code
                                                                                                                                                                                                          - vscode.github-authentication: GitHub Authentication Provider
                                                                                                                                                                                                          - vscode.grunt: Extension to add Grunt capabilities to VS Code.
                                                                                                                                                                                                          - vscode.gulp: Extension to add Gulp capabilities to VSCode.
                                                                                                                                                                                                          - vscode.image-preview: Provides VS Code's built-in image preview
                                                                                                                                                                                                          - vscode.ipynb: Provides basic support for opening and reading Jupyter's .ipynb notebook files
                                                                                                                                                                                                          - vscode.jake: Extension to add Jake capabilities to VS Code.
                                                                                                                                                                                                          - ms-vscode.js-debug: An extension for debugging Node.js programs and Chrome.
                                                                                                                                                                                                          - ms-vscode.js-debug-companion: Companion extension to js-debug that provides capability for remote debugging
                                                                                                                                                                                                          - vscode.markdown-math: Adds math support to Markdown in notebooks.
                                                                                                                                                                                                          - vscode.merge-conflict: Highlighting and commands for inline merge conflicts.
                                                                                                                                                                                                          - vscode.microsoft-authentication: Microsoft authentication provider
                                                                                                                                                                                                          - vscode.npm: Extension to add task support for npm scripts.
                                                                                                                                                                                                          - ms-vscode-remote.remote-wsl-recommender: Recommends using the Windows Subsystem for Linux (WSL) and the Remote WSL extension.
                                                                                                                                                                                                          - vscode.simple-browser: A very basic built-in webview for displaying web content.
                                                                                                                                                                                                          - ms-vscode.vscode-js-profile-table: Text visualizer for profiles taken from the JavaScript debugger

                                                                                                                                                                                                          editor.definitionLinkOpensInPeek

                                                                                                                                                                                                            Controls whether the Go to Definition mouse gesture always opens the peek widget.

                                                                                                                                                                                                            editor.detectIndentation

                                                                                                                                                                                                              Controls whether editor.tabSize# and #editor.insertSpaces will be automatically detected when a file is opened based on the file contents.

                                                                                                                                                                                                              editor.dragAndDrop

                                                                                                                                                                                                                Controls whether the editor should allow moving selections via drag and drop.

                                                                                                                                                                                                                editor.emptySelectionClipboard

                                                                                                                                                                                                                  Controls whether copying without a selection copies the current line.

                                                                                                                                                                                                                  editor.fastScrollSensitivity

                                                                                                                                                                                                                    Scrolling speed multiplier when pressing Alt.

                                                                                                                                                                                                                    editor.find.addExtraSpaceOnTop

                                                                                                                                                                                                                      Controls whether the Find Widget should add extra lines on top of the editor. When true, you can scroll beyond the first line when the Find Widget is visible.

                                                                                                                                                                                                                      editor.find.autoFindInSelection

                                                                                                                                                                                                                        Controls the condition for turning on Find in Selection automatically.
                                                                                                                                                                                                                        - never: Never turn on Find in Selection automatically (default).
                                                                                                                                                                                                                        - always: Always turn on Find in Selection automatically.
                                                                                                                                                                                                                        - multiline: Turn on Find in Selection automatically when multiple lines of content are selected.

                                                                                                                                                                                                                        editor.find.cursorMoveOnType

                                                                                                                                                                                                                          Controls whether the cursor should jump to find matches while typing.

                                                                                                                                                                                                                          editor.find.loop

                                                                                                                                                                                                                            Controls whether the search automatically restarts from the beginning (or the end) when no further matches can be found.

                                                                                                                                                                                                                            editor.find.seedSearchStringFromSelection

                                                                                                                                                                                                                              Controls whether the search string in the Find Widget is seeded from the editor selection.
                                                                                                                                                                                                                              - never: Never seed search string from the editor selection.
                                                                                                                                                                                                                              - always: Always seed search string from the editor selection, including word at cursor position.
                                                                                                                                                                                                                              - selection: Only seed search string from the editor selection.

                                                                                                                                                                                                                              editor.folding

                                                                                                                                                                                                                                Controls whether the editor has code folding enabled.

                                                                                                                                                                                                                                editor.foldingHighlight

                                                                                                                                                                                                                                  Controls whether the editor should highlight folded ranges.

                                                                                                                                                                                                                                  editor.foldingImportsByDefault

                                                                                                                                                                                                                                    Controls whether the editor automatically collapses import ranges.

                                                                                                                                                                                                                                    editor.foldingStrategy

                                                                                                                                                                                                                                      Controls the strategy for computing folding ranges.
                                                                                                                                                                                                                                      - auto: Use a language-specific folding strategy if available, else the indentation-based one.
                                                                                                                                                                                                                                      - indentation: Use the indentation-based folding strategy.

                                                                                                                                                                                                                                      editor.fontFamily

                                                                                                                                                                                                                                        Controls the font family.

                                                                                                                                                                                                                                        editor.fontLigatures

                                                                                                                                                                                                                                          Configures font ligatures or font features. Can be either a boolean to enable/disable ligatures or a string for the value of the CSS 'font-feature-settings' property.

                                                                                                                                                                                                                                          editor.fontSize

                                                                                                                                                                                                                                            Controls the font size in pixels.

                                                                                                                                                                                                                                            editor.fontWeight

                                                                                                                                                                                                                                              Controls the font weight. Accepts "normal" and "bold" keywords or numbers between 1 and 1000.

                                                                                                                                                                                                                                              editor.formatOnPaste

                                                                                                                                                                                                                                                Controls whether the editor should automatically format the pasted content. A formatter must be available and the formatter should be able to format a range in a document.

                                                                                                                                                                                                                                                editor.formatOnSave

                                                                                                                                                                                                                                                  Format a file on save. A formatter must be available, the file must not be saved after delay, and the editor must not be shutting down.

                                                                                                                                                                                                                                                  editor.formatOnSaveMode

                                                                                                                                                                                                                                                    Controls if format on save formats the whole file or only modifications. Only applies when editor.formatOnSave is enabled.
                                                                                                                                                                                                                                                    - file: Format the whole file.
                                                                                                                                                                                                                                                    - modifications: Format modifications (requires source control).
                                                                                                                                                                                                                                                    - modificationsIfAvailable: Will attempt to format modifications only (requires source control). If source control can't be used, then the whole file will be formatted.

                                                                                                                                                                                                                                                    editor.formatOnType

                                                                                                                                                                                                                                                      Controls whether the editor should automatically format the line after typing.

                                                                                                                                                                                                                                                      editor.glyphMargin

                                                                                                                                                                                                                                                        Controls whether the editor should render the vertical glyph margin. Glyph margin is mostly used for debugging.

                                                                                                                                                                                                                                                        editor.gotoLocation.alternativeDeclarationCommand

                                                                                                                                                                                                                                                          Alternative command id that is being executed when the result of 'Go to Declaration' is the current location.

                                                                                                                                                                                                                                                          editor.gotoLocation.alternativeDefinitionCommand

                                                                                                                                                                                                                                                            Alternative command id that is being executed when the result of 'Go to Definition' is the current location.

                                                                                                                                                                                                                                                            editor.gotoLocation.alternativeImplementationCommand

                                                                                                                                                                                                                                                              Alternative command id that is being executed when the result of 'Go to Implementation' is the current location.

                                                                                                                                                                                                                                                              editor.gotoLocation.alternativeReferenceCommand

                                                                                                                                                                                                                                                                Alternative command id that is being executed when the result of 'Go to Reference' is the current location.

                                                                                                                                                                                                                                                                editor.gotoLocation.alternativeTypeDefinitionCommand

                                                                                                                                                                                                                                                                  Alternative command id that is being executed when the result of 'Go to Type Definition' is the current location.

                                                                                                                                                                                                                                                                  editor.gotoLocation.multiple
                                                                                                                                                                                                                                                                  • deprecated

                                                                                                                                                                                                                                                                  This setting is deprecated, please use separate settings like 'editor.editor.gotoLocation.multipleDefinitions' or 'editor.editor.gotoLocation.multipleImplementations' instead.

                                                                                                                                                                                                                                                                  editor.gotoLocation.multipleDeclarations

                                                                                                                                                                                                                                                                    Controls the behavior the 'Go to Declaration'-command when multiple target locations exist.
                                                                                                                                                                                                                                                                    - peek: Show peek view of the results (default)
                                                                                                                                                                                                                                                                    - gotoAndPeek: Go to the primary result and show a peek view
                                                                                                                                                                                                                                                                    - goto: Go to the primary result and enable peek-less navigation to others

                                                                                                                                                                                                                                                                    editor.gotoLocation.multipleDefinitions

                                                                                                                                                                                                                                                                      Controls the behavior the 'Go to Definition'-command when multiple target locations exist.
                                                                                                                                                                                                                                                                      - peek: Show peek view of the results (default)
                                                                                                                                                                                                                                                                      - gotoAndPeek: Go to the primary result and show a peek view
                                                                                                                                                                                                                                                                      - goto: Go to the primary result and enable peek-less navigation to others

                                                                                                                                                                                                                                                                      editor.gotoLocation.multipleImplementations

                                                                                                                                                                                                                                                                        Controls the behavior the 'Go to Implementations'-command when multiple target locations exist.
                                                                                                                                                                                                                                                                        - peek: Show peek view of the results (default)
                                                                                                                                                                                                                                                                        - gotoAndPeek: Go to the primary result and show a peek view
                                                                                                                                                                                                                                                                        - goto: Go to the primary result and enable peek-less navigation to others

                                                                                                                                                                                                                                                                        editor.gotoLocation.multipleReferences

                                                                                                                                                                                                                                                                          Controls the behavior the 'Go to References'-command when multiple target locations exist.
                                                                                                                                                                                                                                                                          - peek: Show peek view of the results (default)
                                                                                                                                                                                                                                                                          - gotoAndPeek: Go to the primary result and show a peek view
                                                                                                                                                                                                                                                                          - goto: Go to the primary result and enable peek-less navigation to others

                                                                                                                                                                                                                                                                          editor.gotoLocation.multipleTypeDefinitions

                                                                                                                                                                                                                                                                            Controls the behavior the 'Go to Type Definition'-command when multiple target locations exist.
                                                                                                                                                                                                                                                                            - peek: Show peek view of the results (default)
                                                                                                                                                                                                                                                                            - gotoAndPeek: Go to the primary result and show a peek view
                                                                                                                                                                                                                                                                            - goto: Go to the primary result and enable peek-less navigation to others

                                                                                                                                                                                                                                                                            editor.hideCursorInOverviewRuler

                                                                                                                                                                                                                                                                              Controls whether the cursor should be hidden in the overview ruler.

                                                                                                                                                                                                                                                                              editor.highlightActiveIndentGuide

                                                                                                                                                                                                                                                                                Controls whether the editor should highlight the active indent guide.

                                                                                                                                                                                                                                                                                editor.hover.delay

                                                                                                                                                                                                                                                                                  Controls the delay in milliseconds after which the hover is shown.

                                                                                                                                                                                                                                                                                  editor.hover.enabled

                                                                                                                                                                                                                                                                                    Controls whether the hover is shown.

                                                                                                                                                                                                                                                                                    editor.hover.sticky

                                                                                                                                                                                                                                                                                      Controls whether the hover should remain visible when mouse is moved over it.

                                                                                                                                                                                                                                                                                      editor.inlayHints.enabled

                                                                                                                                                                                                                                                                                        Enables the inlay hints in the editor.

                                                                                                                                                                                                                                                                                        editor.inlayHints.fontFamily

                                                                                                                                                                                                                                                                                          Controls font family of inlay hints in the editor. When set to empty, the editor.fontFamily is used.

                                                                                                                                                                                                                                                                                          editor.inlayHints.fontSize

                                                                                                                                                                                                                                                                                            Controls font size of inlay hints in the editor. When set to 0, the 90% of editor.fontSize is used.

                                                                                                                                                                                                                                                                                            editor.inlineSuggest.enabled

                                                                                                                                                                                                                                                                                              Controls whether to automatically show inline suggestions in the editor.

                                                                                                                                                                                                                                                                                              editor.inlineSuggest.mode

                                                                                                                                                                                                                                                                                                Controls which mode to use for rendering inline suggestions.
                                                                                                                                                                                                                                                                                                - prefix: Only render an inline suggestion if the replace text is a prefix of the insert text.
                                                                                                                                                                                                                                                                                                - subword: Only render an inline suggestion if the replace text is a subword of the insert text.
                                                                                                                                                                                                                                                                                                - subwordSmart: Only render an inline suggestion if the replace text is a subword of the insert text, but the subword must start after the cursor.

                                                                                                                                                                                                                                                                                                editor.insertSpaces

                                                                                                                                                                                                                                                                                                  Insert spaces when pressing Tab. This setting is overridden based on the file contents when editor.detectIndentation is on.

                                                                                                                                                                                                                                                                                                  editor.largeFileOptimizations

                                                                                                                                                                                                                                                                                                    Special handling for large files to disable certain memory intensive features.

                                                                                                                                                                                                                                                                                                    editor.letterSpacing

                                                                                                                                                                                                                                                                                                      Controls the letter spacing in pixels.

                                                                                                                                                                                                                                                                                                      editor.lightbulb.enabled

                                                                                                                                                                                                                                                                                                        Enables the code action lightbulb in the editor.

                                                                                                                                                                                                                                                                                                        editor.lineHeight

                                                                                                                                                                                                                                                                                                          Controls the line height.
                                                                                                                                                                                                                                                                                                          - Use 0 to automatically compute the line height from the font size.
                                                                                                                                                                                                                                                                                                          - Values between 0 and 8 will be used as a multiplier with the font size.
                                                                                                                                                                                                                                                                                                          - Values greater than or equal to 8 will be used as effective values.

                                                                                                                                                                                                                                                                                                          editor.lineNumbers

                                                                                                                                                                                                                                                                                                            Controls the display of line numbers.
                                                                                                                                                                                                                                                                                                            - off: Line numbers are not rendered.
                                                                                                                                                                                                                                                                                                            - on: Line numbers are rendered as absolute number.
                                                                                                                                                                                                                                                                                                            - relative: Line numbers are rendered as distance in lines to cursor position.
                                                                                                                                                                                                                                                                                                            - interval: Line numbers are rendered every 10 lines.

                                                                                                                                                                                                                                                                                                            editor.linkedEditing

                                                                                                                                                                                                                                                                                                              Controls whether the editor has linked editing enabled. Depending on the language, related symbols, e.g. HTML tags, are updated while editing.

                                                                                                                                                                                                                                                                                                              Controls whether the editor should detect links and make them clickable.

                                                                                                                                                                                                                                                                                                              editor.matchBrackets

                                                                                                                                                                                                                                                                                                                Highlight matching brackets.

                                                                                                                                                                                                                                                                                                                editor.maxTokenizationLineLength

                                                                                                                                                                                                                                                                                                                  Lines above this length will not be tokenized for performance reasons

                                                                                                                                                                                                                                                                                                                  editor.minimap.enabled

                                                                                                                                                                                                                                                                                                                    Controls whether the minimap is shown.

                                                                                                                                                                                                                                                                                                                    editor.minimap.maxColumn

                                                                                                                                                                                                                                                                                                                      Limit the width of the minimap to render at most a certain number of columns.

                                                                                                                                                                                                                                                                                                                      editor.minimap.renderCharacters

                                                                                                                                                                                                                                                                                                                        Render the actual characters on a line as opposed to color blocks.

                                                                                                                                                                                                                                                                                                                        editor.minimap.scale

                                                                                                                                                                                                                                                                                                                          Scale of content drawn in the minimap: 1, 2 or 3.

                                                                                                                                                                                                                                                                                                                          editor.minimap.showSlider

                                                                                                                                                                                                                                                                                                                            Controls when the minimap slider is shown.

                                                                                                                                                                                                                                                                                                                            editor.minimap.side

                                                                                                                                                                                                                                                                                                                              Controls the side where to render the minimap.

                                                                                                                                                                                                                                                                                                                              editor.minimap.size

                                                                                                                                                                                                                                                                                                                                Controls the size of the minimap.
                                                                                                                                                                                                                                                                                                                                - proportional: The minimap has the same size as the editor contents (and might scroll).
                                                                                                                                                                                                                                                                                                                                - fill: The minimap will stretch or shrink as necessary to fill the height of the editor (no scrolling).
                                                                                                                                                                                                                                                                                                                                - fit: The minimap will shrink as necessary to never be larger than the editor (no scrolling).

                                                                                                                                                                                                                                                                                                                                editor.mouseWheelScrollSensitivity

                                                                                                                                                                                                                                                                                                                                  A multiplier to be used on the deltaX and deltaY of mouse wheel scroll events.

                                                                                                                                                                                                                                                                                                                                  editor.mouseWheelZoom

                                                                                                                                                                                                                                                                                                                                    Zoom the font of the editor when using mouse wheel and holding Ctrl.

                                                                                                                                                                                                                                                                                                                                    editor.multiCursorMergeOverlapping

                                                                                                                                                                                                                                                                                                                                      Merge multiple cursors when they are overlapping.

                                                                                                                                                                                                                                                                                                                                      editor.multiCursorModifier

                                                                                                                                                                                                                                                                                                                                        The modifier to be used to add multiple cursors with the mouse. The Go To Definition and Open Link mouse gestures will adapt such that they do not conflict with the multicursor modifier. Read more.
                                                                                                                                                                                                                                                                                                                                        - ctrlCmd: Maps to Control on Windows and Linux and to Command on macOS.
                                                                                                                                                                                                                                                                                                                                        - alt: Maps to Alt on Windows and Linux and to Option on macOS.

                                                                                                                                                                                                                                                                                                                                        editor.multiCursorPaste

                                                                                                                                                                                                                                                                                                                                          Controls pasting when the line count of the pasted text matches the cursor count.
                                                                                                                                                                                                                                                                                                                                          - spread: Each cursor pastes a single line of the text.
                                                                                                                                                                                                                                                                                                                                          - full: Each cursor pastes the full text.

                                                                                                                                                                                                                                                                                                                                          editor.occurrencesHighlight

                                                                                                                                                                                                                                                                                                                                            Controls whether the editor should highlight semantic symbol occurrences.

                                                                                                                                                                                                                                                                                                                                            editor.overviewRulerBorder

                                                                                                                                                                                                                                                                                                                                              Controls whether a border should be drawn around the overview ruler.

                                                                                                                                                                                                                                                                                                                                              editor.padding.bottom

                                                                                                                                                                                                                                                                                                                                                Controls the amount of space between the bottom edge of the editor and the last line.

                                                                                                                                                                                                                                                                                                                                                editor.padding.top

                                                                                                                                                                                                                                                                                                                                                  Controls the amount of space between the top edge of the editor and the first line.

                                                                                                                                                                                                                                                                                                                                                  editor.parameterHints.cycle

                                                                                                                                                                                                                                                                                                                                                    Controls whether the parameter hints menu cycles or closes when reaching the end of the list.

                                                                                                                                                                                                                                                                                                                                                    editor.parameterHints.enabled

                                                                                                                                                                                                                                                                                                                                                      Enables a pop-up that shows parameter documentation and type information as you type.

                                                                                                                                                                                                                                                                                                                                                      editor.peekWidgetDefaultFocus

                                                                                                                                                                                                                                                                                                                                                        Controls whether to focus the inline editor or the tree in the peek widget.
                                                                                                                                                                                                                                                                                                                                                        - tree: Focus the tree when opening peek
                                                                                                                                                                                                                                                                                                                                                        - editor: Focus the editor when opening peek

                                                                                                                                                                                                                                                                                                                                                        editor.quickSuggestions

                                                                                                                                                                                                                                                                                                                                                          Controls whether suggestions should automatically show up while typing.

                                                                                                                                                                                                                                                                                                                                                          editor.quickSuggestionsDelay

                                                                                                                                                                                                                                                                                                                                                            Controls the delay in milliseconds after which quick suggestions will show up.

                                                                                                                                                                                                                                                                                                                                                            editor.rename.enablePreview

                                                                                                                                                                                                                                                                                                                                                              Enable/disable the ability to preview changes before renaming

                                                                                                                                                                                                                                                                                                                                                              editor.renameOnType
                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                              Deprecated, use editor.linkedEditing instead.
                                                                                                                                                                                                                                                                                                                                                              Controls whether the editor auto renames on type.

                                                                                                                                                                                                                                                                                                                                                              editor.renderControlCharacters

                                                                                                                                                                                                                                                                                                                                                                Controls whether the editor should render control characters.

                                                                                                                                                                                                                                                                                                                                                                editor.renderFinalNewline

                                                                                                                                                                                                                                                                                                                                                                  Render last line number when the file ends with a newline.

                                                                                                                                                                                                                                                                                                                                                                  editor.renderIndentGuides

                                                                                                                                                                                                                                                                                                                                                                    Controls whether the editor should render indent guides.

                                                                                                                                                                                                                                                                                                                                                                    editor.renderLineHighlight

                                                                                                                                                                                                                                                                                                                                                                      Controls how the editor should render the current line highlight.
                                                                                                                                                                                                                                                                                                                                                                      - none
                                                                                                                                                                                                                                                                                                                                                                      - gutter
                                                                                                                                                                                                                                                                                                                                                                      - line
                                                                                                                                                                                                                                                                                                                                                                      - all: Highlights both the gutter and the current line.

                                                                                                                                                                                                                                                                                                                                                                      editor.renderLineHighlightOnlyWhenFocus

                                                                                                                                                                                                                                                                                                                                                                        Controls if the editor should render the current line highlight only when the editor is focused.

                                                                                                                                                                                                                                                                                                                                                                        editor.renderWhitespace

                                                                                                                                                                                                                                                                                                                                                                          Controls how the editor should render whitespace characters.
                                                                                                                                                                                                                                                                                                                                                                          - none
                                                                                                                                                                                                                                                                                                                                                                          - boundary: Render whitespace characters except for single spaces between words.
                                                                                                                                                                                                                                                                                                                                                                          - selection: Render whitespace characters only on selected text.
                                                                                                                                                                                                                                                                                                                                                                          - trailing: Render only trailing whitespace characters.
                                                                                                                                                                                                                                                                                                                                                                          - all

                                                                                                                                                                                                                                                                                                                                                                          editor.roundedSelection

                                                                                                                                                                                                                                                                                                                                                                            Controls whether selections should have rounded corners.

                                                                                                                                                                                                                                                                                                                                                                            editor.rulers

                                                                                                                                                                                                                                                                                                                                                                              Render vertical rulers after a certain number of monospace characters. Use multiple values for multiple rulers. No rulers are drawn if array is empty.

                                                                                                                                                                                                                                                                                                                                                                              editor.scrollbar.horizontal

                                                                                                                                                                                                                                                                                                                                                                                Controls the visibility of the horizontal scrollbar.
                                                                                                                                                                                                                                                                                                                                                                                - auto: The horizontal scrollbar will be visible only when necessary.
                                                                                                                                                                                                                                                                                                                                                                                - visible: The horizontal scrollbar will always be visible.
                                                                                                                                                                                                                                                                                                                                                                                - hidden: The horizontal scrollbar will always be hidden.

                                                                                                                                                                                                                                                                                                                                                                                editor.scrollbar.horizontalScrollbarSize

                                                                                                                                                                                                                                                                                                                                                                                  The height of the horizontal scrollbar.

                                                                                                                                                                                                                                                                                                                                                                                  editor.scrollbar.scrollByPage

                                                                                                                                                                                                                                                                                                                                                                                    Controls whether clicks scroll by page or jump to click position.

                                                                                                                                                                                                                                                                                                                                                                                    editor.scrollbar.vertical

                                                                                                                                                                                                                                                                                                                                                                                      Controls the visibility of the vertical scrollbar.
                                                                                                                                                                                                                                                                                                                                                                                      - auto: The vertical scrollbar will be visible only when necessary.
                                                                                                                                                                                                                                                                                                                                                                                      - visible: The vertical scrollbar will always be visible.
                                                                                                                                                                                                                                                                                                                                                                                      - hidden: The vertical scrollbar will always be hidden.

                                                                                                                                                                                                                                                                                                                                                                                      editor.scrollbar.verticalScrollbarSize

                                                                                                                                                                                                                                                                                                                                                                                        The width of the vertical scrollbar.

                                                                                                                                                                                                                                                                                                                                                                                        editor.scrollBeyondLastColumn

                                                                                                                                                                                                                                                                                                                                                                                          Controls the number of extra characters beyond which the editor will scroll horizontally.

                                                                                                                                                                                                                                                                                                                                                                                          editor.scrollBeyondLastLine

                                                                                                                                                                                                                                                                                                                                                                                            Controls whether the editor will scroll beyond the last line.

                                                                                                                                                                                                                                                                                                                                                                                            editor.scrollPredominantAxis

                                                                                                                                                                                                                                                                                                                                                                                              Scroll only along the predominant axis when scrolling both vertically and horizontally at the same time. Prevents horizontal drift when scrolling vertically on a trackpad.

                                                                                                                                                                                                                                                                                                                                                                                              editor.selectionHighlight

                                                                                                                                                                                                                                                                                                                                                                                                Controls whether the editor should highlight matches similar to the selection.

                                                                                                                                                                                                                                                                                                                                                                                                editor.semanticHighlighting.enabled

                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether the semanticHighlighting is shown for the languages that support it.
                                                                                                                                                                                                                                                                                                                                                                                                  - true: Semantic highlighting enabled for all color themes.
                                                                                                                                                                                                                                                                                                                                                                                                  - false: Semantic highlighting disabled for all color themes.
                                                                                                                                                                                                                                                                                                                                                                                                  - configuredByTheme: Semantic highlighting is configured by the current color theme's semanticHighlighting setting.

                                                                                                                                                                                                                                                                                                                                                                                                  editor.semanticTokenColorCustomizations

                                                                                                                                                                                                                                                                                                                                                                                                    Overrides editor semantic token color and styles from the currently selected color theme.

                                                                                                                                                                                                                                                                                                                                                                                                    editor.showDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                      Controls strikethrough deprecated variables.

                                                                                                                                                                                                                                                                                                                                                                                                      editor.showFoldingControls

                                                                                                                                                                                                                                                                                                                                                                                                        Controls when the folding controls on the gutter are shown.
                                                                                                                                                                                                                                                                                                                                                                                                        - always: Always show the folding controls.
                                                                                                                                                                                                                                                                                                                                                                                                        - mouseover: Only show the folding controls when the mouse is over the gutter.

                                                                                                                                                                                                                                                                                                                                                                                                        editor.showUnused

                                                                                                                                                                                                                                                                                                                                                                                                          Controls fading out of unused code.

                                                                                                                                                                                                                                                                                                                                                                                                          editor.smartSelect.selectLeadingAndTrailingWhitespace

                                                                                                                                                                                                                                                                                                                                                                                                            Whether leading and trailing whitespace should always be selected.

                                                                                                                                                                                                                                                                                                                                                                                                            editor.smoothScrolling

                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether the editor will scroll using an animation.

                                                                                                                                                                                                                                                                                                                                                                                                              editor.snippetSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether snippets are shown with other suggestions and how they are sorted.
                                                                                                                                                                                                                                                                                                                                                                                                                - top: Show snippet suggestions on top of other suggestions.
                                                                                                                                                                                                                                                                                                                                                                                                                - bottom: Show snippet suggestions below other suggestions.
                                                                                                                                                                                                                                                                                                                                                                                                                - inline: Show snippets suggestions with other suggestions.
                                                                                                                                                                                                                                                                                                                                                                                                                - none: Do not show snippet suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                editor.stablePeek

                                                                                                                                                                                                                                                                                                                                                                                                                  Keep peek editors open even when double clicking their content or when hitting Escape.

                                                                                                                                                                                                                                                                                                                                                                                                                  editor.stickyTabStops

                                                                                                                                                                                                                                                                                                                                                                                                                    Emulate selection behavior of tab characters when using spaces for indentation. Selection will stick to tab stops.

                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggest.filteredTypes
                                                                                                                                                                                                                                                                                                                                                                                                                    • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                    This setting is deprecated, please use separate settings like 'editor.suggest.showKeywords' or 'editor.suggest.showSnippets' instead.

                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggest.filterGraceful

                                                                                                                                                                                                                                                                                                                                                                                                                      Controls whether filtering and sorting suggestions accounts for small typos.

                                                                                                                                                                                                                                                                                                                                                                                                                      editor.suggest.insertMode

                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether words are overwritten when accepting completions. Note that this depends on extensions opting into this feature.
                                                                                                                                                                                                                                                                                                                                                                                                                        - insert: Insert suggestion without overwriting text right of the cursor.
                                                                                                                                                                                                                                                                                                                                                                                                                        - replace: Insert suggestion and overwrite text right of the cursor.

                                                                                                                                                                                                                                                                                                                                                                                                                        editor.suggest.localityBonus

                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether sorting favors words that appear close to the cursor.

                                                                                                                                                                                                                                                                                                                                                                                                                          editor.suggest.maxVisibleSuggestions
                                                                                                                                                                                                                                                                                                                                                                                                                          • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                          This setting is deprecated. The suggest widget can now be resized.

                                                                                                                                                                                                                                                                                                                                                                                                                          editor.suggest.preview

                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to preview the suggestion outcome in the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                            editor.suggest.previewMode

                                                                                                                                                                                                                                                                                                                                                                                                                              Controls which mode to use for rendering the suggest preview.
                                                                                                                                                                                                                                                                                                                                                                                                                              - prefix: Only render a preview if the replace text is a prefix of the insert text.
                                                                                                                                                                                                                                                                                                                                                                                                                              - subword: Only render a preview if the replace text is a subword of the insert text.
                                                                                                                                                                                                                                                                                                                                                                                                                              - subwordSmart: Render a preview if the replace text is a subword of the insert text, or if it is a prefix of the insert text.

                                                                                                                                                                                                                                                                                                                                                                                                                              editor.suggest.shareSuggestSelections

                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether remembered suggestion selections are shared between multiple workspaces and windows (needs editor.suggestSelection).

                                                                                                                                                                                                                                                                                                                                                                                                                                editor.suggest.showClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled IntelliSense shows class-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.suggest.showColors

                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled IntelliSense shows color-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggest.showConstants

                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled IntelliSense shows constant-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                      editor.suggest.showConstructors

                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled IntelliSense shows constructor-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                        editor.suggest.showCustomcolors

                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled IntelliSense shows customcolor-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                          editor.suggest.showDeprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled IntelliSense shows deprecated-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                            editor.suggest.showEnumMembers

                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled IntelliSense shows enumMember-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                              editor.suggest.showEnums

                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled IntelliSense shows enum-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                editor.suggest.showEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled IntelliSense shows event-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.suggest.showFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled IntelliSense shows field-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggest.showFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled IntelliSense shows file-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      editor.suggest.showFolders

                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled IntelliSense shows folder-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        editor.suggest.showFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled IntelliSense shows function-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          editor.suggest.showIcons

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to show or hide icons in suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            editor.suggest.showInlineDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether suggest details show inline with the label or only in the details widget

                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor.suggest.showInterfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled IntelliSense shows interface-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                editor.suggest.showIssues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled IntelliSense shows issues-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.suggest.showKeywords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled IntelliSense shows keyword-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggest.showMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled IntelliSense shows method-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      editor.suggest.showModules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled IntelliSense shows module-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        editor.suggest.showOperators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled IntelliSense shows operator-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          editor.suggest.showProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled IntelliSense shows property-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            editor.suggest.showReferences

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled IntelliSense shows reference-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor.suggest.showSnippets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled IntelliSense shows snippet-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                editor.suggest.showStatusBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the visibility of the status bar at the bottom of the suggest widget.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.suggest.showStructs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled IntelliSense shows struct-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggest.showTypeParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled IntelliSense shows typeParameter-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      editor.suggest.showUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled IntelliSense shows unit-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        editor.suggest.showUsers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled IntelliSense shows user-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          editor.suggest.showValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled IntelliSense shows value-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            editor.suggest.showVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled IntelliSense shows variable-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor.suggest.showWords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled IntelliSense shows text-suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                editor.suggest.snippetsPreventQuickSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether an active snippet prevents quick suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.suggestFontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Font size for the suggest widget. When set to 0, the value of editor.fontSize is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.suggestLineHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Line height for the suggest widget. When set to 0, the value of editor.lineHeight is used. The minimum value is 8.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      editor.suggestOnTriggerCharacters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether suggestions should automatically show up when typing trigger characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        editor.suggestSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls how suggestions are pre-selected when showing the suggest list.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - first: Always select the first suggestion.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - recentlyUsed: Select recent suggestions unless further typing selects one, e.g. console.| -> console.log because log has been completed recently.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - recentlyUsedByPrefix: Select suggestions based on previous prefixes that have completed those suggestions, e.g. co -> console and con -> const.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          editor.tabCompletion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enables tab completions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - on: Tab complete will insert the best matching suggestion when pressing tab.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - off: Disable tab completions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - onlySnippets: Tab complete snippets when their prefix match. Works best when 'quickSuggestions' aren't enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            editor.tabSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The number of spaces a tab is equal to. This setting is overridden based on the file contents when editor.detectIndentation is on.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor.tokenColorCustomizations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Overrides editor syntax colors and font style from the currently selected color theme.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                editor.trimAutoWhitespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Remove trailing auto inserted whitespace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.unfoldOnClickAfterEndOfLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether clicking on the empty content after a folded line will unfold the line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.unusualLineTerminators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Remove unusual line terminators that might cause problems.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - auto: Unusual line terminators are automatically removed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - off: Unusual line terminators are ignored.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - prompt: Unusual line terminators prompt to be removed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      editor.useTabStops

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Inserting and deleting whitespace follows tab stops.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        editor.wordBasedSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether completions should be computed based on words in the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          editor.wordBasedSuggestionsMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls from which documents word based completions are computed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - currentDocument: Only suggest words from the active document.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - matchingDocuments: Suggest words from all open documents of the same language.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - allDocuments: Suggest words from all open documents.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            editor.wordSeparators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Characters that will be used as word separators when doing word related navigations or operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              editor.wordWrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls how lines should wrap.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - off: Lines will never wrap.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - on: Lines will wrap at the viewport width.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - wordWrapColumn: Lines will wrap at editor.wordWrapColumn.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - bounded: Lines will wrap at the minimum of viewport and editor.wordWrapColumn.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                editor.wordWrapColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the wrapping column of the editor when editor.wordWrap is wordWrapColumn or bounded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  editor.wrappingIndent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls the indentation of wrapped lines.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - none: No indentation. Wrapped lines begin at column 1.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - same: Wrapped lines get the same indentation as the parent.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - indent: Wrapped lines get +1 indentation toward the parent.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - deepIndent: Wrapped lines get +2 indentation toward the parent.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    editor.wrappingStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls the algorithm that computes wrapping points.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - simple: Assumes that all characters are of the same width. This is a fast algorithm that works correctly for monospace fonts and certain scripts (like Latin characters) where glyphs are of equal width.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - advanced: Delegates wrapping points computation to the browser. This is a slow algorithm, that might cause freezes for large files, but it works correctly in all cases.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      emmet
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      emmet.excludeLanguages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An array of languages where Emmet abbreviations should not be expanded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        emmet.extensionsPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An array of paths, where each path can contain Emmet syntaxProfiles and/or snippet files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          In case of conflicts, the profiles/snippets of later paths will override those of earlier paths.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See https://code.visualstudio.com/docs/editor/emmet for more information and an example snippet file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          emmet.includeLanguages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable Emmet abbreviations in languages that are not supported by default. Add a mapping here between the language and Emmet supported language.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For example: {"vue-html": "html", "javascript": "javascriptreact"}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            emmet.optimizeStylesheetParsing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When set to false, the whole file is parsed to determine if current position is valid for expanding Emmet abbreviations. When set to true, only the content around the current position in CSS/SCSS/Less files is parsed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              emmet.preferences

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Preferences used to modify behavior of some actions and resolvers of Emmet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                emmet.showAbbreviationSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Shows possible Emmet abbreviations as suggestions. Not applicable in stylesheets or when emmet.showExpandedAbbreviation is set to "never".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  emmet.showExpandedAbbreviation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Shows expanded Emmet abbreviations as suggestions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The option "inMarkupAndStylesheetFilesOnly" applies to html, haml, jade, slim, xml, xsl, css, scss, sass, less and stylus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The option "always" applies to all parts of the file regardless of markup/css.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emmet.showSuggestionsAsSnippets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      If true, then Emmet suggestions will show up as snippets allowing you to order them as per editor.snippetSuggestions setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      emmet.syntaxProfiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Define profile for specified syntax or use your own profile with specific rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        emmet.triggerExpansionOnTab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled, Emmet abbreviations are expanded when pressing TAB.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          emmet.variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Variables to be used in Emmet snippets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            explorer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            explorer.autoReveal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether the explorer should automatically reveal and select files when opening them.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - true: Files will be revealed and selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - false: Files will not be revealed and selected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - focusNoScroll: Files will not be scrolled into view, but will still be focused.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              explorer.compactFolders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether the explorer should render folders in a compact form. In such a form, single child folders will be compressed in a combined tree element. Useful for Java package structures, for example.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                explorer.confirmDelete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether the explorer should ask for confirmation when deleting a file via the trash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  explorer.confirmDragAndDrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether the explorer should ask for confirmation to move files and folders via drag and drop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    explorer.copyRelativePathSeparator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The path separation character used when copying relative file paths.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - /: Use slash as path separation character.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - \: Use backslash as path separation character.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - auto: Uses operating system specific path separation character.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      explorer.decorations.badges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether file decorations should use badges.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        explorer.decorations.colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether file decorations should use colors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          explorer.enableDragAndDrop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether the explorer should allow to move files and folders via drag and drop. This setting only effects drag and drop from inside the explorer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            explorer.incrementalNaming

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls what naming strategy to use when a giving a new name to a duplicated explorer item on paste.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - simple: Appends the word "copy" at the end of the duplicated name potentially followed by a number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - smart: Adds a number at the end of the duplicated name. If some number is already part of the name, tries to increase that number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              explorer.openEditors.sortOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the sorting order of editors in the Open Editors pane.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - editorOrder: Editors are ordered in the same order editor tabs are shown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - alphabetical: Editors are ordered in alphabetical order inside each editor group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                explorer.openEditors.visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Number of editors shown in the Open Editors pane. Setting this to 0 hides the Open Editors pane.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  explorer.sortOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls the property-based sorting of files and folders in the explorer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - default: Files and folders are sorted by their names. Folders are displayed before files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - mixed: Files and folders are sorted by their names. Files are interwoven with folders.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - filesFirst: Files and folders are sorted by their names. Files are displayed before folders.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - type: Files and folders are grouped by extension type then sorted by their names. Folders are displayed before files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - modified: Files and folders are sorted by last modified date in descending order. Folders are displayed before files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    explorer.sortOrderLexicographicOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls the lexicographic sorting of file and folder names in the Explorer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - default: Uppercase and lowercase names are mixed together.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - upper: Uppercase names are grouped together before lowercase names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - lower: Lowercase names are grouped together before uppercase names.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - unicode: Names are sorted in unicode order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extensions.autoCheckUpdates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled, automatically checks extensions for updates. If an extension has an update, it is marked as outdated in the Extensions view. The updates are fetched from a Microsoft online service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extensions.autoUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls the automatic update behavior of extensions. The updates are fetched from a Microsoft online service.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - true: Download and install updates automatically for all extensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - onlyEnabledExtensions: Download and install updates automatically only for enabled extensions. Disabled extensions will not be updated automatically.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - false: Extensions are not automatically updated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extensions.closeExtensionDetailsOnViewChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled, editors with extension details will be automatically closed upon navigating away from the Extensions View.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extensions.confirmedUriHandlerExtensionIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When an extension is listed here, a confirmation prompt will not be shown when that extension handles a URI.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extensions.ignoreRecommendations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled, the notifications for extension recommendations will not be shown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extensions.showRecommendationsOnlyOnDemand
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This setting is deprecated. Use extensions.ignoreRecommendations setting to control recommendation notifications. Use Extensions view's visibility actions to hide Recommended view by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extensions.supportUntrustedWorkspaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Override the untrusted workspace support of an extension. Extensions using true will always be enabled. Extensions using limited will always be enabled, and the extension will hide functionality that requires trust. Extensions using false will only be enabled only when the workspace is trusted.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extensions.supportVirtualWorkspaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Override the virtual workspaces support of an extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    extensions.webWorker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable web worker extension host.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - true: The Web Worker Extension Host will always be launched.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - false: The Web Worker Extension Host will never be launched.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - auto: The Web Worker Extension Host will be launched when a web extension needs it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      files
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      files.associations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Configure file associations to languages (e.g. "*.extension": "html"). These have precedence over the default associations of the languages installed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        files.autoGuessEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled, the editor will attempt to guess the character set encoding when opening files. This setting can also be configured per language. Note, this setting is not respected by text search. Only files.encoding is respected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          files.autoSave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls auto save of dirty editors. Read more about autosave here.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - off: A dirty editor is never automatically saved.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - afterDelay: A dirty editor is automatically saved after the configured files.autoSaveDelay.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - onFocusChange: A dirty editor is automatically saved when the editor loses focus.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - onWindowChange: A dirty editor is automatically saved when the window loses focus.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            files.autoSaveDelay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the delay in ms after which a dirty editor is saved automatically. Only applies when files.autoSave is set to afterDelay.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              files.defaultLanguage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The default language mode that is assigned to new files. If configured to ${activeEditorLanguage}, will use the language mode of the currently active text editor if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                files.enableTrash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Moves files/folders to the OS trash (recycle bin on Windows) when deleting. Disabling this will delete files/folders permanently.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  files.encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The default character set encoding to use when reading and writing files. This setting can also be configured per language.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - utf8: UTF-8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - utf8bom: UTF-8 with BOM
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - utf16le: UTF-16 LE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - utf16be: UTF-16 BE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1252: Western (Windows 1252)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88591: Western (ISO 8859-1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88593: Western (ISO 8859-3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso885915: Western (ISO 8859-15)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - macroman: Western (Mac Roman)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - cp437: DOS (CP 437)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1256: Arabic (Windows 1256)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88596: Arabic (ISO 8859-6)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1257: Baltic (Windows 1257)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88594: Baltic (ISO 8859-4)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso885914: Celtic (ISO 8859-14)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1250: Central European (Windows 1250)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88592: Central European (ISO 8859-2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - cp852: Central European (CP 852)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1251: Cyrillic (Windows 1251)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - cp866: Cyrillic (CP 866)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88595: Cyrillic (ISO 8859-5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - koi8r: Cyrillic (KOI8-R)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - koi8u: Cyrillic (KOI8-U)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso885913: Estonian (ISO 8859-13)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1253: Greek (Windows 1253)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88597: Greek (ISO 8859-7)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1255: Hebrew (Windows 1255)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88598: Hebrew (ISO 8859-8)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso885910: Nordic (ISO 8859-10)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso885916: Romanian (ISO 8859-16)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1254: Turkish (Windows 1254)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso88599: Turkish (ISO 8859-9)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows1258: Vietnamese (Windows 1258)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - gbk: Simplified Chinese (GBK)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - gb18030: Simplified Chinese (GB18030)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - cp950: Traditional Chinese (Big5)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - big5hkscs: Traditional Chinese (Big5-HKSCS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - shiftjis: Japanese (Shift JIS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - eucjp: Japanese (EUC-JP)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - euckr: Korean (EUC-KR)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - windows874: Thai (Windows 874)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - iso885911: Latin/Thai (ISO 8859-11)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - koi8ru: Cyrillic (KOI8-RU)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - koi8t: Tajik (KOI8-T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - gb2312: Simplified Chinese (GB 2312)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - cp865: Nordic DOS (CP 865)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - cp850: Western European DOS (CP 850)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    files.eol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The default end of line character.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - \n: LF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - \r\n: CRLF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - auto: Uses operating system specific end of line character.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      files.exclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Configure glob patterns for excluding files and folders. For example, the file Explorer decides which files and folders to show or hide based on this setting. Refer to the search.exclude setting to define search specific excludes. Read more about glob patterns here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        files.hotExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - off: Disable hot exit. A prompt will show when attempting to close a window with dirty files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - onExit: Hot exit will be triggered when the last window is closed on Windows/Linux or when the workbench.action.quit command is triggered (command palette, keybinding, menu). All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via File > Open Recent > More...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - onExitAndWindowClose: Hot exit will be triggered when the last window is closed on Windows/Linux or when the workbench.action.quit command is triggered (command palette, keybinding, menu), and also for any window with a folder opened regardless of whether it's the last window. All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via File > Open Recent > More...

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          files.insertFinalNewline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled, insert a final new line at the end of the file when saving it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            files.maxMemoryForLargeFilesMB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the memory available to VS Code after restart when trying to open large files. Same effect as specifying --max-memory=NEWSIZE on the command line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              files.participants.timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Timeout in milliseconds after which file participants for create, rename, and delete are cancelled. Use 0 to disable participants.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                files.restoreUndoStack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Restore the undo stack when a file is reopened.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  files.saveConflictResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A save conflict can occur when a file is saved to disk that was changed by another program in the meantime. To prevent data loss, the user is asked to compare the changes in the editor with the version on disk. This setting should only be changed if you frequently encounter save conflict errors and may result in data loss if used without caution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - askUser: Will refuse to save and ask for resolving the save conflict manually.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - overwriteFileOnDisk: Will resolve the save conflict by overwriting the file on disk with the changes in the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    files.simpleDialog.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enables the simple file dialog. The simple file dialog replaces the system file dialog when enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      files.trimFinalNewlines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled, will trim all new lines after the final new line at the end of the file when saving it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        files.trimTrailingWhitespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled, will trim trailing whitespace when saving a file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          files.watcherExclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configure glob patterns of file paths to exclude from file watching. Patterns must match on absolute paths, i.e. prefix with **/ or the full path to match properly and suffix with /** to match files within a path (for example **/build/output/** or /Users/name/workspaces/project/build/output/**). Changing this setting requires a restart. When you experience Code consuming lots of CPU time on startup, you can exclude large folders to reduce the initial load.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            g

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.allowForcePush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether force push (with or without lease) is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.allowNoVerifyCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether commits without running pre-commit and commit-msg hooks are allowed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.alwaysShowStagedChangesResourceGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Always show the Staged Changes resource group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.alwaysSignOff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls the signoff flag for all commits.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.autofetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When set to true, commits will automatically be fetched from the default remote of the current Git repository. Setting to all will fetch from all remotes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.autofetchPeriod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Duration in seconds between each automatic git fetch, when git.autofetch is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.autorefresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Whether auto refreshing is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.autoRepositoryDetection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configures when repositories should be automatically detected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - true: Scan for both subfolders of the current opened folder and parent folders of open files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - false: Disable automatic repository scanning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - subFolders: Scan for subfolders of the currently opened folder.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - openEditors: Scan for parent folders of open files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.autoStash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Stash any changes before pulling and restore them after successful pull.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.branchSortOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the sort order for branches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.branchValidationRegex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A regular expression to validate new branch names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.branchWhitespaceChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The character to replace whitespace in new branch names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.checkoutType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls what type of git refs are listed when running Checkout to....
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - local: Local branches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - tags: Tags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - remote: Remote branches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.confirmEmptyCommits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Always confirm the creation of empty commits for the 'Git: Commit Empty' command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.confirmForcePush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether to ask for confirmation before force-pushing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.confirmNoVerifyCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to ask for confirmation before committing without verification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.confirmSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Confirm before synchronizing git repositories.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.countBadge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the Git count badge.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - all: Count all changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - tracked: Count only tracked changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - off: Turn off counter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.decorations.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether Git contributes colors and badges to the Explorer and the Open Editors view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.defaultCloneDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The default location to clone a git repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.detectSubmodules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls whether to automatically detect git submodules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.detectSubmodulesLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls the limit of git submodules detected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.enableCommitSigning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enables commit signing with GPG or X.509.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether git is enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.enableSmartCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Commit all changes when there are no staged changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.enableStatusBarSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether the Git Sync command appears in the status bar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.fetchOnPull

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled, fetch all branches when pulling. Otherwise, fetch just the current one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.followTagsWhenSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Follow push all tags when running the sync command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.githubAuthentication
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This setting is now deprecated, please use github.gitAuthentication instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.ignoredRepositories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      List of git repositories to ignore.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.ignoreLegacyWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Ignores the legacy Git warning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.ignoreLimitWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Ignores the warning when there are too many changes in a repository.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.ignoreMissingGitWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ignores the warning when Git is missing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.ignoreRebaseWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Ignores the warning when it looks like the branch might have been rebased when pulling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.ignoreSubmodules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Ignore modifications to submodules in the file tree.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.ignoreWindowsGit27Warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Ignores the warning when Git 2.25 - 2.26 is installed on Windows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.inputValidation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls when to show commit message input validation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.inputValidationLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls the commit message length threshold for showing a warning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.inputValidationSubjectLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls the commit message subject length threshold for showing a warning. Unset it to inherit the value of config.inputValidationLength.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.openAfterClone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether to open a repository automatically after cloning.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - always: Always open in current window.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - alwaysNewWindow: Always open in a new window.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - whenNoFolderOpen: Only open in current window when no folder is opened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - prompt: Always prompt for action.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.openDiffOnClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether the diff editor should be opened when clicking a change. Otherwise the regular editor will be opened.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Path and filename of the git executable, e.g. C:\Program Files\Git\bin\git.exe (Windows). This can also be an array of string values containing multiple paths to look up.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.postCommitCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Runs a git command after a successful commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - none: Don't run any command after a commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - push: Run 'Git Push' after a successful commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - sync: Run 'Git Sync' after a successful commit.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.promptToSaveFilesBeforeCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether Git should check for unsaved files before committing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - always: Check for any unsaved files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - staged: Check only for unsaved staged files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - never: Disable this check.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.promptToSaveFilesBeforeStash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether Git should check for unsaved files before stashing changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - always: Check for any unsaved files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - staged: Check only for unsaved staged files.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - never: Disable this check.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.pruneOnFetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Prune when fetching.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.pullTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fetch all tags when pulling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.rebaseWhenSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Force git to use rebase when running the sync command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.requireGitUserConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to require explicit Git user configuration or allow Git to guess if missing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.scanRepositories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              List of paths to search for git repositories in.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.showCommitInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether to show the commit input in the Git source control panel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.showInlineOpenFileAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether to show an inline Open File action in the Git changes view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.showProgress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether git actions should show progress.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.showPushSuccessNotification

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls whether to show a notification when a push is successful.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.smartCommitChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Control which changes are automatically staged by Smart Commit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - all: Automatically stage all changes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - tracked: Automatically stage tracked changes only.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        git.suggestSmartCommit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Suggests to enable smart commit (commit all changes when there are no staged changes).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          git.supportCancellation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether a notification comes up when running the Sync action, which allows the user to cancel the operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            git.terminalAuthentication

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether to enable VS Code to be the authentication handler for git processes spawned in the integrated terminal. Note: terminals need to be restarted to pick up a change in this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              git.timeline.date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls which date to use for items in the Timeline view.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - committed: Use the committed date
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - authored: Use the authored date

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                git.timeline.showAuthor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether to show the commit author in the Timeline view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  git.untrackedChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls how untracked changes behave.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - mixed: All changes, tracked and untracked, appear together and behave equally.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - separate: Untracked changes appear separately in the Source Control view. They are also excluded from several actions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - hidden: Untracked changes are hidden and excluded from several actions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    git.useCommitInputAsStashMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls whether to use the message from the commit input box as the default stash message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      git.useForcePushWithLease

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether force pushing uses the safer force-with-lease variant.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        github-enterprise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        github-enterprise.uri

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          URI of your GitHub Enterprise Instance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          github
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          github.gitAuthentication

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to enable automatic GitHub authentication for git commands within VS Code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            grunt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            grunt.autoDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls enablement of Grunt task detection. Grunt task detection can cause files in any open workspace to be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              gulp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              gulp.autoDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls enablement of Gulp task detection. Gulp task detection can cause files in any open workspace to be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [git-commit]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [git-commit]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configure settings to be overridden for [git-commit] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [git-rebase]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [git-rebase]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure settings to be overridden for [git-rebase] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [go]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [go]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configure settings to be overridden for [go] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      h

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      html
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      html.autoClosingTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable/disable autoclosing of HTML tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        html.customData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A list of relative file paths pointing to JSON files following the custom data format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VS Code loads custom data on startup to enhance its HTML support for the custom HTML tags, attributes and attribute values you specify in the JSON files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The file paths are relative to workspace and only workspace folder settings are considered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          html.format.contentUnformatted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            List of tags, comma separated, where the content shouldn't be reformatted. null defaults to the pre tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            html.format.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable/disable default HTML formatter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              html.format.endWithNewline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                End with a newline.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                html.format.extraLiners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  List of tags, comma separated, that should have an extra newline before them. null defaults to "head, body, /html".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  html.format.indentHandlebars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Format and indent {{#foo}} and {{/foo}}.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html.format.indentInnerHtml

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Indent <head> and <body> sections.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      html.format.maxPreserveNewLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Maximum number of line breaks to be preserved in one chunk. Use null for unlimited.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        html.format.preserveNewLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether existing line breaks before elements should be preserved. Only works before elements, not inside tags or for text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          html.format.templating

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Honor django, erb, handlebars and php templating language tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            html.format.unformatted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              List of tags, comma separated, that shouldn't be reformatted. null defaults to all tags listed at https://www.w3.org/TR/html5/dom.html#phrasing-content.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              html.format.unformattedContentDelimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Keep text content together between this string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                html.format.wrapAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Wrap attributes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - auto: Wrap attributes only when line length is exceeded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - force: Wrap each attribute except first.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - force-aligned: Wrap each attribute except first and keep aligned.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - force-expand-multiline: Wrap each attribute.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - aligned-multiple: Wrap when line length is exceeded, align attributes vertically.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - preserve: Preserve wrapping of attributes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - preserve-aligned: Preserve wrapping of attributes but align.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  html.format.wrapAttributesIndentSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Alignment size when using 'force aligned' and 'aligned multiple' in html.format.wrapAttributes or null to use the default indent size.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    html.format.wrapLineLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Maximum amount of characters per line (0 = disable).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      html.hover.documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Show tag and attribute documentation in hover.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        html.hover.references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Show references to MDN in hover.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          html.mirrorCursorOnMatchingTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated in favor of editor.linkedEditing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable/disable mirroring cursor on matching HTML tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          html.suggest.html5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether the built-in HTML language support suggests HTML5 tags, properties and values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            html.trace.server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Traces the communication between VS Code and the HTML language server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              html.validate.scripts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether the built-in HTML language support validates embedded scripts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                html.validate.styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether the built-in HTML language support validates embedded styles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  http
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  http.proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The proxy setting to use. If not set, will be inherited from the http_proxy and https_proxy environment variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    http.proxyAuthorization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The value to send as the Proxy-Authorization header for every network request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      http.proxyStrictSSL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether the proxy server certificate should be verified against the list of supplied CAs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        http.proxySupport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use the proxy support for extensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - off: Disable proxy support for extensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - on: Enable proxy support for extensions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - fallback: Enable proxy support for extensions, fall back to request options, when no proxy found.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - override: Enable proxy support for extensions, override request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          http.systemCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether CA certificates should be loaded from the OS. (On Windows and macOS, a reload of the window is required after turning this off.)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [handlebars]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [handlebars]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configure settings to be overridden for [handlebars] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [html]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [html]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Configure settings to be overridden for [html] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                j

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                jake
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                jake.autoDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls enablement of Jake task detection. Jake task detection can cause files in any open workspace to be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript.autoClosingTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enable/disable automatic closing of JSX tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript.format.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable/disable default JavaScript formatter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.format.insertSpaceAfterCommaDelimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Defines space handling after a comma delimiter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        javascript.format.insertSpaceAfterConstructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines space handling after the constructor keyword.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          javascript.format.insertSpaceAfterFunctionKeywordForAnonymousFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines space handling after function keyword for anonymous functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            javascript.format.insertSpaceAfterKeywordsInControlFlowStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines space handling after keywords in a control flow statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              javascript.format.insertSpaceAfterOpeningAndBeforeClosingEmptyBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines space handling after opening and before closing empty braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                javascript.format.insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines space handling after opening and before closing JSX expression braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines space handling after opening and before closing non-empty braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines space handling after opening and before closing non-empty brackets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Defines space handling after opening and before closing non-empty parenthesis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        javascript.format.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines space handling after opening and before closing template string braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          javascript.format.insertSpaceAfterSemicolonInForStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines space handling after a semicolon in a for statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            javascript.format.insertSpaceBeforeAndAfterBinaryOperators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines space handling after a binary operator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              javascript.format.insertSpaceBeforeFunctionParenthesis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines space handling before function argument parentheses.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                javascript.format.placeOpenBraceOnNewLineForControlBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines whether an open brace is put onto a new line for control blocks or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript.format.placeOpenBraceOnNewLineForFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines whether an open brace is put onto a new line for functions or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript.format.semicolons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines handling of optional semicolons. Requires using TypeScript 3.7 or newer in the workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - ignore: Don't insert or remove any semicolons.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - insert: Insert semicolons at statement ends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - remove: Remove unnecessary semicolons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.implicitProjectConfig.checkJs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This setting has been deprecated in favor of js/ts.implicitProjectConfig.checkJs.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable/disable semantic checking of JavaScript files. Existing jsconfig.json or tsconfig.json files override this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.implicitProjectConfig.experimentalDecorators
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This setting has been deprecated in favor of js/ts.implicitProjectConfig.experimentalDecorators.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable/disable experimentalDecorators in JavaScript files that are not part of a project. Existing jsconfig.json or tsconfig.json files override this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.inlayHints.enumMemberValues.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable/disable inlay hints for member values in enum declarations:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum MyValue {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A /* = 0 */;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        B /* = 1 */;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Requires using TypeScript 4.4+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        javascript.inlayHints.functionLikeReturnTypes.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable/disable inlay hints for implicit return types on function signatures:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function foo() /* :number */ {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return Date.now();
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Requires using TypeScript 4.4+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          javascript.inlayHints.parameterNames.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable/disable inlay hints for parameter names:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parseInt(/* str: */ '123', /* radix: */ 8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Requires using TypeScript 4.4+ in the workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - none: Disable parameter name hints.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - literals: Enable parameter name hints only for literal arguments.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - all: Enable parameter name hints for literal and non-literal arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            javascript.inlayHints.parameterNames.suppressWhenArgumentMatchesName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Suppress parameter name hints on arguments whose text is identical to the parameter name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              javascript.inlayHints.parameterTypes.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable/disable inlay hints for implicit parameter types:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                el.addEventListener('click', e /* :MouseEvent */ => ...)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Requires using TypeScript 4.4+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                javascript.inlayHints.propertyDeclarationTypes.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enable/disable inlay hints for implicit types on property declarations:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Foo {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prop /* :number */ = Date.now;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Requires using TypeScript 4.4+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript.inlayHints.variableTypes.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enable/disable inlay hints for implicit variable types:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const foo /* :number */ = Date.now();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Requires using TypeScript 4.4+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript.preferences.importModuleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Preferred path style for auto imports.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - shortest: Prefers a non-relative import only if one is available that has fewer path segments than a relative import.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - relative: Prefers a relative path to the imported file location.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - non-relative: Prefers a non-relative import based on the baseUrl or paths configured in your jsconfig.json / tsconfig.json.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - project-relative: Prefers a non-relative import only if the relative import path would leave the package or project directory. Requires using TypeScript 4.2+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.preferences.importModuleSpecifierEnding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Preferred path ending for auto imports.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - auto: Use project settings to select a default.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - minimal: Shorten ./component/index.js to ./component.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - index: Shorten ./component/index.js to ./component/index.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - js: Do not shorten path endings; include the .js extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        javascript.preferences.quoteStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Preferred quote style to use for quick fixes: single quotes, double quotes, or auto infer quote type from existing imports.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          javascript.preferences.renameShorthandProperties
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The setting 'typescript.preferences.renameShorthandProperties' has been deprecated in favor of 'typescript.preferences.useAliasesForRenames'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable/disable introducing aliases for object shorthand properties during renames. Requires using TypeScript 3.4 or newer in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          javascript.preferences.useAliasesForRenames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable/disable introducing aliases for object shorthand properties during renames. Requires using TypeScript 3.4 or newer in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            javascript.referencesCodeLens.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable/disable references CodeLens in JavaScript files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              javascript.referencesCodeLens.showOnAllFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable/disable references CodeLens on all functions in JavaScript files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                javascript.suggest.autoImports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enable/disable auto import suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript.suggest.completeFunctionCalls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Complete functions with their parameter signature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript.suggest.completeJSDocs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable/disable suggestion to complete JSDoc comments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.suggest.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enabled/disable autocomplete suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        javascript.suggest.includeAutomaticOptionalChainCompletions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable/disable showing completions on potentially undefined values that insert an optional chain call. Requires TS 3.7+ and strict null checks to be enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          javascript.suggest.includeCompletionsForImportStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable/disable auto-import-style completions on partially-typed import statements. Requires using TypeScript 4.3+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            javascript.suggest.jsdoc.generateReturns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable/disable generating @return annotations for JSDoc templates. Requires using TypeScript 4.2+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              javascript.suggest.names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable/disable including unique names from the file in JavaScript suggestions. Note that name suggestions are always disabled in JavaScript code that is semantically checked using @ts-check or checkJs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                javascript.suggest.paths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enable/disable suggestions for paths in import statements and require calls.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  javascript.suggestionActions.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enable/disable suggestion diagnostics for JavaScript files in the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    javascript.updateImportsOnFileMove.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Enable/disable automatic updating of import paths when you rename or move a file in VS Code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - prompt: Prompt on each rename.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - always: Always update paths automatically.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - never: Never rename paths and don't prompt.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      javascript.validate.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable/disable JavaScript validation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        js/ts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        js/ts.implicitProjectConfig.checkJs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable/disable semantic checking of JavaScript files. Existing jsconfig.json or tsconfig.json files override this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          js/ts.implicitProjectConfig.experimentalDecorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable/disable experimentalDecorators in JavaScript files that are not part of a project. Existing jsconfig.json or tsconfig.json files override this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            js/ts.implicitProjectConfig.strictFunctionTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable/disable strict function types in JavaScript and TypeScript files that are not part of a project. Existing jsconfig.json or tsconfig.json files override this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              js/ts.implicitProjectConfig.strictNullChecks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable/disable strict null checks in JavaScript and TypeScript files that are not part of a project. Existing jsconfig.json or tsconfig.json files override this setting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                json
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                json.colorDecorators.enable
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The setting json.colorDecorators.enable has been deprecated in favor of editor.colorDecorators.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enables or disables color decorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                json.format.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enable/disable default JSON formatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  json.maxItemsComputed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The maximum number of outline symbols and folding regions computed (limited for performance reasons).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    json.schemaDownload.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled, JSON schemas can be fetched from http and https locations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      json.schemas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Associate schemas to JSON files in the current project.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        json.trace.server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Traces the communication between VS Code and the JSON language server.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [jsonc]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [jsonc]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configure settings to be overridden for [jsonc] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [json]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [json]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configure settings to be overridden for [json] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              l

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              launch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              launch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Global debug launch configuration. Should be used as an alternative to 'launch.json' that is shared across workspaces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                less
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                less.completion.completePropertyWithSemicolon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Insert semicolon at end of line when completing CSS properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  less.completion.triggerPropertyValueCompletion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    By default, VS Code triggers property value completion after selecting a CSS property. Use this setting to disable this behavior.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    less.hover.documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Show tag and attribute documentation in LESS hovers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      less.hover.references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Show references to MDN in LESS hovers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        less.lint.argumentsInColorFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Invalid number of parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          less.lint.boxModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Do not use width or height when using padding or border.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            less.lint.compatibleVendorPrefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When using a vendor-specific prefix make sure to also include all other vendor-specific properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              less.lint.duplicateProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Do not use duplicate style definitions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                less.lint.emptyRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Do not use empty rulesets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  less.lint.float

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Avoid using float. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    less.lint.fontFaceProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      @font-face rule must define src and font-family properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      less.lint.hexColorLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Hex colors must consist of three or six hex numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        less.lint.idSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Selectors should not contain IDs because these rules are too tightly coupled with the HTML.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          less.lint.ieHack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IE hacks are only necessary when supporting IE7 and older.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            less.lint.important

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Avoid using !important. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              less.lint.importStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Import statements do not load in parallel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                less.lint.propertyIgnoredDueToDisplay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Property is ignored due to the display. E.g. with display: inline, the width, height, margin-top, margin-bottom, and float properties have no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  less.lint.universalSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The universal selector (*) is known to be slow.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    less.lint.unknownAtRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Unknown at-rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      less.lint.unknownProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Unknown property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        less.lint.unknownVendorSpecificProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Unknown vendor specific property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          less.lint.validProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A list of properties that are not validated against the unknownProperties rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            less.lint.vendorPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When using a vendor-specific prefix, also include the standard property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              less.lint.zeroUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No unit for zero needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                less.validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enables or disables all validations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [less]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [less]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure settings to be overridden for [less] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    m

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markdown.links.openLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls where links in Markdown files should be opened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - currentGroup: Open links in the active editor group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - beside: Open links beside the active editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      markdown.math.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable/disable rendering math in the built-in Markdown preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        markdown.preview.breaks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sets how line-breaks are rendered in the Markdown preview. Setting it to 'true' creates a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          for newlines inside paragraphs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          markdown.preview.doubleClickToSwitchToEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Double click in the Markdown preview to switch to the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            markdown.preview.fontFamily

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the font family used in the Markdown preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              markdown.preview.fontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the font size in pixels used in the Markdown preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                markdown.preview.lineHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the line height used in the Markdown preview. This number is relative to the font size.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  markdown.preview.linkify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enable or disable conversion of URL-like text to links in the Markdown preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    markdown.preview.markEditorSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Mark the current editor selection in the Markdown preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls how links to other Markdown files in the Markdown preview should be opened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - inPreview: Try to open links in the Markdown preview.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - inEditor: Try to open links in the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      markdown.preview.scrollEditorWithPreview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When a Markdown preview is scrolled, update the view of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        markdown.preview.scrollPreviewWithEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When a Markdown editor is scrolled, update the view of the preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          markdown.preview.typographer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable or disable some language-neutral replacement and quotes beautification in the Markdown preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            markdown.styles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A list of URLs or local paths to CSS style sheets to use from the Markdown preview. Relative paths are interpreted relative to the folder open in the Explorer. If there is no open folder, they are interpreted relative to the location of the Markdown file. All '\' need to be written as '\\'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              markdown.trace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable debug logging for the Markdown extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge-conflict
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                merge-conflict.autoNavigateNextConflict.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Whether to automatically navigate to the next merge conflict after resolving a merge conflict.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  merge-conflict.codeLens.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Create a CodeLens for merge conflict blocks within editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    merge-conflict.decorators.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Create decorators for merge conflict blocks within editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      merge-conflict.diffViewPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls where the diff view should be opened when comparing changes in merge conflicts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Current: Open the diff view in the current editor group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Beside: Open the diff view next to the current editor group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - Below: Open the diff view below the current editor group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [makefile]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [makefile]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Configure settings to be overridden for [makefile] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [markdown]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [markdown]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configure settings to be overridden for [markdown] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            n

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notebook
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notebook.breadcrumbs.showCodeCells

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled notebook breadcrumbs contain code cells.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              notebook.cellFocusIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls where the focus indicator is rendered, either along the cell borders or on the left gutter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notebook.cellToolbarLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Where the cell toolbar should be shown, or whether it should be hidden.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notebook.cellToolbarVisibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Whether the cell toolbar should appear on hover or click.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    notebook.compactView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Control whether the notebook editor should be rendered in a compact form. For example, when turned on, it will decrease the left margin width.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      notebook.consolidatedOutputButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Control whether outputs action should be rendered in the output toolbar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        notebook.consolidatedRunButton

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Control whether extra actions are shown in a dropdown next to the run button.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          notebook.diff.enablePreview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether to use the enhanced text diff editor for notebook.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notebook.diff.ignoreMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hide Metadata Differences

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              notebook.diff.ignoreOutputs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Hide Outputs Differences

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notebook.displayOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Priority list for output mime types

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notebook.dragAndDropEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Control whether the notebook editor should allow moving cells through drag and drop.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    notebook.editorOptionsCustomizations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Settings for code editors used in notebooks. This can be used to customize most editor.* settings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      notebook.globalToolbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Control whether to render a global toolbar inside the notebook editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        notebook.globalToolbarShowLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Control whether the actions on the notebook toolbar should render label or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          notebook.insertToolbarLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Control where the insert cell actions should appear.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - betweenCells: A toolbar that appears on hover between cells.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - notebookToolbar: The toolbar at the top of the notebook editor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - both: Both toolbars.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - hidden: The insert actions don't appear anywhere.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            notebook.lineNumbers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the display of line numbers in the cell editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              notebook.navigation.allowNavigateToSurroundingCells

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled cursor can navigate to the next/previous cell when the current cursor in the cell editor is at the first/last line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                notebook.outline.showCodeCells

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled notebook outline shows code cells.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notebook.output.textLineLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Control how many lines of text in a text output is rendered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    notebook.showCellStatusBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Whether the cell status bar should be shown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - hidden: The cell Status bar is always hidden.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - visible: The cell Status bar is always visible.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - visibleAfterExecute: The cell Status bar is hidden until the cell has executed. Then it becomes visible to show the execution status.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      notebook.showFoldingControls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls when the Markdown header folding arrow is shown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - always: The folding controls are always visible.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - mouseover: The folding controls are visible only on mouseover.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        notebook.undoRedoPerCell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Whether to use separate undo/redo stack for each cell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          npm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          npm.autoDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether npm scripts should be automatically detected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            npm.enableRunFromFolder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable running npm scripts contained in a folder from the Explorer context menu.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              npm.enableScriptExplorer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The NPM Script Explorer is now available in 'Views' menu in the Explorer in all folders.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable an explorer view for npm scripts when there is no top-level 'package.json' file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                npm.exclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configure glob patterns for folders that should be excluded from automatic script detection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  npm.fetchOnlinePackageInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fetch data from https://registry.npmjs.org and https://registry.bower.io to provide auto-completion and information on hover features on npm dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    npm.packageManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The package manager used to run scripts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - auto: Auto-detect which package manager to use for running scripts based on lock files and installed package managers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - npm: Use npm as the package manager for running scripts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - yarn: Use yarn as the package manager for running scripts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - pnpm: Use pnpm as the package manager for running scripts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      npm.runSilent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Run npm commands with the --silent option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        npm.scriptExplorerAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The default click action used in the npm scripts explorer: open or run, the default is open.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          o

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outline
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outline.icons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Render Outline Elements with Icons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outline.problems.badges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use badges for Errors & Warnings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outline.problems.colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use colors for Errors & Warnings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outline.problems.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Show Errors & Warnings on Outline Elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outline.showArrays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled outline shows array-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outline.showBooleans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled outline shows boolean-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      outline.showClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled outline shows class-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        outline.showConstants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled outline shows constant-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outline.showConstructors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled outline shows constructor-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outline.showEnumMembers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled outline shows enumMember-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outline.showEnums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled outline shows enum-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outline.showEvents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled outline shows event-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outline.showFields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled outline shows field-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outline.showFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled outline shows file-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      outline.showFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled outline shows function-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        outline.showInterfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled outline shows interface-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outline.showKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled outline shows key-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outline.showMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled outline shows method-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outline.showModules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled outline shows module-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outline.showNamespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled outline shows namespace-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outline.showNull

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled outline shows null-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outline.showNumbers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled outline shows number-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      outline.showObjects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled outline shows object-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        outline.showOperators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled outline shows operator-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          outline.showPackages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When enabled outline shows package-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outline.showProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled outline shows property-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outline.showStrings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                When enabled outline shows string-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                outline.showStructs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  When enabled outline shows struct-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outline.showTypeParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    When enabled outline shows typeParameter-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outline.showVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled outline shows variable-symbols.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      output
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      output.smartScroll.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable/disable the ability of smart scrolling in the output view. Smart scrolling allows you to lock scrolling automatically when you click in the output view and unlocks when you click in the last line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        p

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        php
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        php.suggest.basic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether the built-in PHP language suggestions are enabled. The support suggests PHP globals and variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          php.validate.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enable/disable built-in PHP validation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            php.validate.executablePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Points to the PHP executable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              php.validate.run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether the linter is run on save or on type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                problems
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                problems.autoReveal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether Problems view should automatically reveal files when opening them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  problems.decorations.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Show Errors & Warnings on files and folder.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    problems.showCurrentInStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      When enabled shows the current problem in the status bar.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      r

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      references
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      references.preferredLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether 'Peek References' or 'Find References' is invoked when selecting code lens references
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - peek: Show references in peek editor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - view: Show references in separate view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        remote
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        remote.autoForwardPorts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled, new running processes are detected and ports that they listen on are automatically forwarded. Disabling this setting will not prevent all ports from being forwarded. Even when disabled, extensions will still be able to cause ports to be forwarded, and opening some URLs will still cause ports to forwarded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          remote.autoForwardPortsSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Sets the source from which ports are automatically forwarded when remote.autoForwardPorts is true. On Windows and Mac remotes, the process option has no effect and output will be used. Requires a reload to take effect.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - process: Ports will be automatically forwarded when discovered by watching for processes that are started and include a port.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - output: Ports will be automatically forwarded when discovered by reading terminal and debug output. Not all processes that use ports will print to the integrated terminal or debug console, so some ports will be missed. Ports forwarded based on output will not be "un-forwarded" until reload or until the port is closed by the user in the Ports view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            remote.downloadExtensionsLocally

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When enabled extensions are downloaded locally and installed on remote.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remote.extensionKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Override the kind of an extension. ui extensions are installed and run on the local machine while workspace extensions are run on the remote. By overriding an extension's default kind using this setting, you specify if that extension should be installed and enabled locally or remotely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                remote.localPortHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Specifies the local host name that will be used for port forwarding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remote.otherPortsAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Set default properties that are applied to all ports that don't get properties from the setting remote.portsAttributes. For example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "onAutoForward": "ignore"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    `

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    remote.portsAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Set properties that are applied when a specific port number is forwarded. For example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "3000": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "label": "Application"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "40000-55000": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "onAutoForward": "ignore"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ".+\\/server.js": {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "onAutoForward": "openPreview"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      `

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      remote.restoreForwardedPorts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Restores the ports you forwarded in a workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scm.alwaysShowActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether inline actions are always visible in the Source Control view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scm.alwaysShowRepositories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether repositories should always be visible in the SCM view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scm.autoReveal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether the SCM view should automatically reveal and select files when opening them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scm.countBadge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the count badge on the Source Control icon on the Activity Bar.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - all: Show the sum of all Source Control Provider count badges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - focused: Show the count badge of the focused Source Control Provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - off: Disable the Source Control count badge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scm.defaultViewMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the default Source Control repository view mode.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - tree: Show the repository changes as a tree.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - list: Show the repository changes as a list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scm.diffDecorations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls diff decorations in the editor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - all: Show the diff decorations in all available locations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - gutter: Show the diff decorations only in the editor gutter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - overview: Show the diff decorations only in the overview ruler.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - minimap: Show the diff decorations only in the minimap.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - none: Do not show the diff decorations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scm.diffDecorationsGutterAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls the behavior of Source Control diff gutter decorations.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - diff: Show the inline diff peek view on click.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - none: Do nothing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scm.diffDecorationsGutterVisibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls the visibility of the Source Control diff decorator in the gutter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - always: Show the diff decorator in the gutter at all times.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - hover: Show the diff decorator in the gutter only on hover.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scm.diffDecorationsGutterWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls the width(px) of diff decorations in gutter (added & modified).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scm.inputFontFamily

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls the font for the input message. Use default for the workbench user interface font family, editor for the editor.fontFamily's value, or a custom font family.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scm.inputFontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the font size for the input message in pixels.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scm.providerCountBadge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the count badges on Source Control Provider headers. These headers only appear when there is more than one provider.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - hidden: Hide Source Control Provider count badges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - auto: Only show count badge for Source Control Provider when non-zero.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - visible: Show Source Control Provider count badges.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scm.repositories.visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls how many repositories are visible in the Source Control Repositories section. Set to 0 to be able to manually resize the view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  screencastMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  screencastMode.fontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls the font size (in pixels) of the screencast mode keyboard.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    screencastMode.keyboardOverlayTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls how long (in milliseconds) the keyboard overlay is shown in screencast mode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      screencastMode.mouseIndicatorColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls the color in hex (#RGB, #RGBA, #RRGGBB or #RRGGBBAA) of the mouse indicator in screencast mode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        screencastMode.mouseIndicatorSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls the size (in pixels) of the mouse indicator in screencast mode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          screencastMode.onlyKeyboardShortcuts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Only show keyboard shortcuts in screencast mode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            screencastMode.verticalOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the vertical offset of the screencast mode overlay from the bottom as a percentage of the workbench height.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scss
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scss.completion.completePropertyWithSemicolon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Insert semicolon at end of line when completing CSS properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scss.completion.triggerPropertyValueCompletion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  By default, VS Code triggers property value completion after selecting a CSS property. Use this setting to disable this behavior.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scss.hover.documentation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Show tag and attribute documentation in SCSS hovers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scss.hover.references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Show references to MDN in SCSS hovers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scss.lint.argumentsInColorFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Invalid number of parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scss.lint.boxModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Do not use width or height when using padding or border.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scss.lint.compatibleVendorPrefixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When using a vendor-specific prefix make sure to also include all other vendor-specific properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scss.lint.duplicateProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Do not use duplicate style definitions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scss.lint.emptyRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Do not use empty rulesets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scss.lint.float

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Avoid using float. Floats lead to fragile CSS that is easy to break if one aspect of the layout changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scss.lint.fontFaceProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @font-face rule must define src and font-family properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scss.lint.hexColorLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Hex colors must consist of three or six hex numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scss.lint.idSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Selectors should not contain IDs because these rules are too tightly coupled with the HTML.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scss.lint.ieHack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          IE hacks are only necessary when supporting IE7 and older.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scss.lint.important

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Avoid using !important. It is an indication that the specificity of the entire CSS has gotten out of control and needs to be refactored.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scss.lint.importStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Import statements do not load in parallel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scss.lint.propertyIgnoredDueToDisplay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Property is ignored due to the display. E.g. with display: inline, the width, height, margin-top, margin-bottom, and float properties have no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scss.lint.universalSelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The universal selector (*) is known to be slow.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scss.lint.unknownAtRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Unknown at-rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scss.lint.unknownProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Unknown property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scss.lint.unknownVendorSpecificProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Unknown vendor specific property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scss.lint.validProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A list of properties that are not validated against the unknownProperties rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scss.lint.vendorPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When using a vendor-specific prefix, also include the standard property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scss.lint.zeroUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No unit for zero needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scss.validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enables or disables all validations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                search
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                search.actionsPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the positioning of the actionbar on rows in the search view.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - auto: Position the actionbar to the right when the search view is narrow, and immediately after the content when the search view is wide.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - right: Always position the actionbar to the right.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  search.collapseResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether the search results will be collapsed or expanded.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - auto: Files with less than 10 results are expanded. Others are collapsed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - alwaysCollapse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - alwaysExpand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    search.exclude

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configure glob patterns for excluding files and folders in fulltext searches and quick open. Inherits all glob patterns from the files.exclude setting. Read more about glob patterns here.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      search.experimental.forceExtensionHostSearch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        When enabled, search always runs in the extension host instead of a separate search process.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether to follow symlinks while searching.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        search.location
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This setting is deprecated. You can drag the search icon to a new location instead.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether the search will be shown as a view in the sidebar or as a panel in the panel area for more horizontal space.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        search.maintainFileSearchCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled, the searchService process will be kept alive instead of being shut down after an hour of inactivity. This will keep the file search cache in memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          search.maxResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls the maximum number of search results, this can be set to null (empty) to return unlimited results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search.mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls where new Search: Find in Files and Find in Folder operations occur: either in the sidebar's search view, or in a search editor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - view: Search in the search view, either in the panel or sidebar.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - reuseEditor: Search in an existing search editor if present, otherwise in a new search editor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - newEditor: Search in a new search editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              search.quickOpen.history.filterSortOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls sorting order of editor history in quick open when filtering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - default: History entries are sorted by relevance based on the filter value used. More relevant entries appear first.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - recency: History entries are sorted by recency. More recently opened entries appear first.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                search.quickOpen.includeHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Whether to include results from recently opened files in the file results for Quick Open.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  search.quickOpen.includeSymbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Whether to include results from a global symbol search in the file results for Quick Open.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    search.searchEditor.defaultNumberOfContextLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The default number of surrounding context lines to use when creating new Search Editors. If using search.searchEditor.reusePriorSearchConfiguration, this can be set to null (empty) to use the prior Search Editor's configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      search.searchEditor.doubleClickBehaviour

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Configure effect of double clicking a result in a search editor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - selectWord: Double clicking selects the word under the cursor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - goToLocation: Double clicking opens the result in the active editor group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - openLocationToSide: Double clicking opens the result in the editor group to the side, creating one if it does not yet exist.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        search.searchEditor.reusePriorSearchConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          When enabled, new Search Editors will reuse the includes, excludes, and flags of the previously opened Search Editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          search.searchOnType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Search all files as you type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search.searchOnTypeDebouncePeriod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              When search.searchOnType is enabled, controls the timeout in milliseconds between a character being typed and the search starting. Has no effect when search.searchOnType is disabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              search.seedOnFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Update the search query to the editor's selected text when focusing the search view. This happens either on click or when triggering the workbench.views.search.focus command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                search.seedWithNearestWord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enable seeding search from the word nearest the cursor when the active editor has no selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  search.showLineNumbers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether to show line numbers for search results.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    search.smartCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Search case-insensitively if the pattern is all lowercase, otherwise, search case-sensitively.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      search.sortOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls sorting order of search results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - default: Results are sorted by folder and file names, in alphabetical order.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - fileNames: Results are sorted by file names ignoring folder order, in alphabetical order.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - type: Results are sorted by file extensions, in alphabetical order.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - modified: Results are sorted by file last modified date, in descending order.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - countDescending: Results are sorted by count per file, in descending order.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - countAscending: Results are sorted by count per file, in ascending order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        search.useGlobalIgnoreFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether to use global .gitignore and .ignore files when searching for files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          search.useIgnoreFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to use .gitignore and .ignore files when searching for files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search.usePCRE2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated. PCRE2 will be used automatically when using regex features that are only supported by PCRE2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether to use the PCRE2 regex engine in text search. This enables using some advanced regex features like lookahead and backreferences. However, not all PCRE2 features are supported - only features that are also supported by JavaScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            search.useReplacePreview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether to open Replace Preview when selecting or replacing a match.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              search.useRipgrep
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated. Consider "search.usePCRE2" for advanced regex feature support.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This setting is deprecated and now falls back on "search.usePCRE2".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              security
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              security.workspace.trust.banner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls when the restricted mode banner is shown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - always: Show the banner every time an untrusted workspace is open.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - untilDismissed: Show the banner when an untrusted workspace is opened until dismissed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - never: Do not show the banner when an untrusted workspace is open.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                security.workspace.trust.emptyWindow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether or not the empty window is trusted by default within VS Code. When used with security.workspace.trust.untrustedFiles, you can enable the full functionality of VS Code without prompting in an empty window.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  security.workspace.trust.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether or not workspace trust is enabled within VS Code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    security.workspace.trust.startupPrompt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls when the startup prompt to trust a workspace is shown.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - always: Ask for trust every time an untrusted workspace is opened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - once: Ask for trust the first time an untrusted workspace is opened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - never: Do not ask for trust when an untrusted workspace is opened.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      security.workspace.trust.untrustedFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls how to handle opening untrusted files in a trusted workspace. This setting also applies to opening files in an empty window which is trusted via security.workspace.trust.emptyWindow.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - prompt: Ask how to handle untrusted files for each workspace. Once untrusted files are introduced to a trusted workspace, you will not be prompted again.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - open: Always allow untrusted files to be introduced to a trusted workspace without prompting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - newWindow: Always open untrusted files in a separate window in restricted mode without prompting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        settingsSync
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        settingsSync.ignoredExtensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          List of extensions to be ignored while synchronizing. The identifier of an extension is always ${publisher}.${name}. For example: vscode.csharp.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          settingsSync.ignoredSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Configure settings to be ignored while synchronizing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            settingsSync.keybindingsPerPlatform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Synchronize keybindings for each platform.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              simpleBrowser
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              simpleBrowser.focusLockIndicator.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable/disable the floating indicator that shows when focused in the simple browser.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [scss]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [scss]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Configure settings to be overridden for [scss] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [search-result]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [search-result]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Configure settings to be overridden for [search-result] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [shellscript]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [shellscript]

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configure settings to be overridden for [shellscript] language.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      t

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      task
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      task.autoDetect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls enablement of provideTasks for all task provider extension. If the Tasks: Run Task command is slow, disabling auto detect for task providers may help. Individual extensions may also provide settings that disable auto detection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        task.problemMatchers.neverPrompt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Configures whether to show the problem matcher prompt when running a task. Set to true to never prompt, or use a dictionary of task types to turn off prompting only for specific task types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          task.quickOpen.detail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to show the task detail for tasks that have a detail in task quick picks, such as Run Task.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            task.quickOpen.history

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the number of recent items tracked in task quick open dialog.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              task.quickOpen.showAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Causes the Tasks: Run Task command to use the slower "show all" behavior instead of the faster two level picker where tasks are grouped by provider.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                task.quickOpen.skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls whether the task quick pick is skipped when there is only one task to pick from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  task.saveBeforeRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Save all dirty editors before running a task.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - always: Always saves all editors before running.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - never: Never saves editors before running.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - prompt: Prompts whether to save editors before running.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    task.slowProviderWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Configures whether a warning is shown when a provider is slow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      telemetry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      telemetry.enableCrashReporter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enable crash reports to be collected. This helps us improve stability.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This option requires restart to take effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        telemetry.enableTelemetry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable diagnostic data to be collected. This helps us to better understand how Visual Studio Code is performing and where improvements need to be made. Read more about what we collect and our privacy statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.explorerKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Customizes what kind of terminal to launch.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - integrated: Use VS Code's integrated terminal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - external: Use the configured external terminal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.external.linuxExec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Customizes which terminal to run on Linux.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.external.osxExec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Customizes which terminal application to run on macOS.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.external.windowsExec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Customizes which terminal to run on Windows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.allowChords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Whether or not to allow chord keybindings in the terminal. Note that when this is true and the keystroke results in a chord it will bypass terminal.integrated.commandsToSkipShell, setting this to false is particularly useful when you want ctrl+k to go to your shell (not VS Code).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.allowMnemonics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Whether to allow menubar mnemonics (eg. alt+f) to trigger the open the menubar. Note that this will cause all alt keystrokes to skip the shell when true. This does nothing on macOS.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.altClickMovesCursor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If enabled, alt/option + click will reposition the prompt cursor to underneath the mouse when editor.multiCursorModifier is set to 'alt' (the default value). This may not work reliably depending on your shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.automationShell.linux

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A path that when set will override terminal.integrated.shell.linux and ignore shellArgs values for automation-related terminal usage like tasks and debug.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.automationShell.osx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A path that when set will override terminal.integrated.shell.osx and ignore shellArgs values for automation-related terminal usage like tasks and debug.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.automationShell.windows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A path that when set will override terminal.integrated.shell.windows and ignore shellArgs values for automation-related terminal usage like tasks and debug.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.bellDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The number of milliseconds to show the bell within a terminal tab when triggered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.commandsToSkipShell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A set of command IDs whose keybindings will not be sent to the shell but instead always be handled by VS Code. This allows keybindings that would normally be consumed by the shell to act instead the same as when the terminal is not focused, for example Ctrl+P to launch Quick Open.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Many commands are skipped by default. To override a default and pass that command's keybinding to the shell instead, add the command prefixed with the - character. For example add -workbench.action.quickOpen to allow Ctrl+P to reach the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The following list of default skipped commands is truncated when viewed in Settings Editor. To see the full list, [open the default settings JSON](command:workbench.action.openRawDefaultSettings 'Open Default Settings (JSON)') and search for the first command from the list below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Default Skipped Commands:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - editor.action.toggleTabFocusMode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - notifications.hideList
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - notifications.hideToasts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.continue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.pause
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.restart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.run
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.start
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.stepInto
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.stepOut
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.stepOver
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.debug.stop
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.firstEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusActiveEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusEighthEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusFifthEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusFirstEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusFourthEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusLastEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusNextPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusPreviousPart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusSecondEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusSeventhEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusSixthEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.focusThirdEditorGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.lastEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.navigateDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.navigateLeft
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.navigateRight
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.navigateUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.nextEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.nextEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.nextPanelView
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.nextSideBarView
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.openNextRecentlyUsedEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.openNextRecentlyUsedEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.openPreviousRecentlyUsedEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.openPreviousRecentlyUsedEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.previousEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.previousEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.previousPanelView
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.previousSideBarView
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpenLeastRecentlyUsedEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpenLeastRecentlyUsedEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpenPreviousEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpenPreviousRecentlyUsedEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.quickOpenView
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.showCommands
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.build
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.reRunTask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.restartTask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.runTask
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.showLog
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.showTasks
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.terminate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.tasks.test
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.clear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.clearSelection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.copySelection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.deleteToLineStart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.deleteWordLeft
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.deleteWordRight
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.findNext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.findPrevious
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focus
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusAtIndex9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusFind
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusNext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusNextPane
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusPrevious
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.focusPreviousPane
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.hideFind
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.kill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.killEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.moveToEditor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.moveToLineEnd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.moveToLineStart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.moveToTerminalPanel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.navigationModeExit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.navigationModeFocusNext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.navigationModeFocusPrevious
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.new
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.newInActiveWorkspace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.paste
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.pasteSelection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.resizePaneDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.resizePaneLeft
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.resizePaneRight
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.resizePaneUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.runActiveFile
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.runSelectedText
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollDown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollDownPage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollToBottom
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollToNextCommand
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollToPreviousCommand
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollToTop
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollUp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.scrollUpPage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.selectAll
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.selectToNextCommand
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.selectToNextLine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.selectToPreviousCommand
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.selectToPreviousLine
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.sendSequence
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.split
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.splitInActiveWorkspace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.toggleFindCaseSensitive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.toggleFindRegex
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.toggleFindWholeWord
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.terminal.toggleTerminal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.toggleFullScreen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.toggleMaximizedPanel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - workbench.action.togglePanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.confirmOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls whether to confirm when the window closes if there are active terminal sessions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - never: Never confirm.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - always: Always confirm if there are terminals.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - hasChildProcesses: Confirm if there are any terminals that have child processes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.confirmOnKill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls whether to confirm killing terminals when they have child processes. When set to editor, terminals in the editor area will be marked as dirty when they have child processes. Note that child process detection may not work well for shells like Git Bash which don't run their processes as child processes of the shell.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - never: Never confirm.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - editor: Confirm if the terminal is in the editor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - panel: Confirm if the terminal is in the panel.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - always: Confirm if the terminal is either in the editor or panel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.copyOnSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether text selected in the terminal will be copied to the clipboard.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.cursorBlinking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether the terminal cursor blinks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.cursorStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls the style of terminal cursor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.cursorWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the width of the cursor when terminal.integrated.cursorStyle is set to line.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.customGlyphs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether to draw custom glyphs for block element and box drawing characters instead of using the font, which typically yields better rendering with continuous lines. Note that this doesn't work with the DOM renderer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.cwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  An explicit start path where the terminal will be launched, this is used as the current working directory (cwd) for the shell process. This may be particularly useful in workspace settings if the root directory is not a convenient cwd.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.defaultLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls where newly created terminals will appear.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - editor: Create terminals in the editor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - view: Create terminals in the terminal view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.defaultProfile.linux

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The default profile used on Linux. This setting will currently be ignored if either terminal.integrated.shell.linux or terminal.integrated.shellArgs.linux are set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.defaultProfile.osx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The default profile used on macOS. This setting will currently be ignored if either terminal.integrated.shell.osx or terminal.integrated.shellArgs.osx are set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.defaultProfile.windows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The default profile used on Windows. This setting will currently be ignored if either terminal.integrated.shell.windows or terminal.integrated.shellArgs.windows are set.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - PowerShell: $(terminal-powershell) PowerShell
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - path: C:\Program Files\PowerShell\7\pwsh.exe
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - Command Prompt: $(terminal-cmd) Command Prompt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - path: C:\WINDOWS\System32\cmd.exe
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - args: []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - Git Bash: $(terminal) Git Bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - path: C:\Program Files\Git\bin\bash.exe
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - args: ['--login']
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - JavaScript Debug Terminal: $($(debug)) JavaScript Debug Terminal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - extensionIdenfifier: ms-vscode.js-debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.detectLocale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether to detect and set the $LANG environment variable to a UTF-8 compliant option since VS Code's terminal only supports UTF-8 encoded data coming from the shell.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - auto: Set the $LANG environment variable if the existing variable does not exist or it does not end in '.UTF-8'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - off: Do not set the $LANG environment variable.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - on: Always set the $LANG environment variable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.drawBoldTextInBrightColors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls whether bold text in the terminal will always use the "bright" ANSI color variant.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.enableBell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether the terminal bell is enabled, this shows up as a visual bell next to the terminal's name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether to enable file links in the terminal. Links can be slow when working on a network drive in particular because each file link is verified against the file system. Changing this will take effect only in new terminals.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.enablePersistentSessions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Persist terminal sessions for the workspace across window reloads.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.env.linux

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Object with environment variables that will be added to the VS Code process to be used by the terminal on Linux. Set to null to delete the environment variable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.env.osx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Object with environment variables that will be added to the VS Code process to be used by the terminal on macOS. Set to null to delete the environment variable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.env.windows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Object with environment variables that will be added to the VS Code process to be used by the terminal on Windows. Set to null to delete the environment variable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.environmentChangesIndicator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Whether to display the environment changes indicator on each terminal which explains whether extensions have made, or want to make changes to the terminal's environment.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - off: Disable the indicator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - on: Enable the indicator.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - warnonly: Only show the warning indicator when a terminal's environment is 'stale', not the information indicator that shows a terminal has had its environment modified by an extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.environmentChangesRelaunch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether to relaunch terminals automatically if extension want to contribute to their environment and have not been interacted with yet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.experimentalLinkProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An experimental setting that aims to improve link detection in the terminal by improving when links are detected and by enabling shared link detection with the editor. Currently this only supports web links.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.fastScrollSensitivity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Scrolling speed multiplier when pressing Alt.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.fontFamily

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the font family of the terminal, this defaults to editor.fontFamily's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.fontSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls the font size in pixels of the terminal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.fontWeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The font weight to use within the terminal for non-bold text. Accepts "normal" and "bold" keywords or numbers between 1 and 1000.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.fontWeightBold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The font weight to use within the terminal for bold text. Accepts "normal" and "bold" keywords or numbers between 1 and 1000.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.gpuAcceleration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether the terminal will leverage the GPU to do its rendering.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - auto: Let VS Code detect which renderer will give the best experience.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - on: Enable GPU acceleration within the terminal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - off: Disable GPU acceleration within the terminal.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - canvas: Use the fallback canvas renderer within the terminal. This uses a 2d context instead of webgl and may be better on some systems.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.inheritEnv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Whether new shells should inherit their environment from VS Code, which may source a login shell to ensure $PATH and other development variables are initialized. This has no effect on Windows.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.letterSpacing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the letter spacing of the terminal, this is an integer value which represents the amount of additional pixels to add between characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.lineHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls the line height of the terminal, this number is multiplied by the terminal font size to get the actual line-height in pixels.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.localEchoExcludePrograms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Experimental: local echo will be disabled when any of these program names are found in the terminal title.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.localEchoLatencyThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Experimental: length of network delay, in milliseconds, where local edits will be echoed on the terminal without waiting for server acknowledgement. If '0', local echo will always be on, and if '-1' it will be disabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.localEchoStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Experimental: terminal style of locally echoed text; either a font style or an RGB color.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.macOptionClickForcesSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether to force selection when using Option+click on macOS. This will force a regular (line) selection and disallow the use of column selection mode. This enables copying and pasting using the regular terminal selection, for example, when mouse mode is enabled in tmux.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.macOptionIsMeta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether to treat the option key as the meta key in the terminal on macOS.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.minimumContrastRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            When set the foreground color of each cell will change to try meet the contrast ratio specified. Example values:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - 1: The default, do nothing.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - 4.5: WCAG AA compliance (minimum).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - 7: WCAG AA compliance (minimum).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - 21: White on black or black on white.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.mouseWheelScrollSensitivity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              A multiplier to be used on the deltaY of mouse wheel scroll events.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.persistentSessionExperimentalSerializer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Whether to use a more efficient experimental approach for restoring the terminal's buffer. This setting requires a restart to take effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.persistentSessionScrollback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Controls the maximum amount of lines that will be restored when reconnecting to a persistent terminal session. Increasing this will restore more lines of scrollback at the cost of more memory and increase the time it takes to connect to terminals on start up. This setting requires a restart to take effect and should be set to a value less than or equal to terminal.integrated.scrollback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.profiles.linux

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The Linux profiles to present when creating a new terminal via the terminal dropdown. When set, these will override the default detected profiles. They are comprised of a path and optional args.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.profiles.osx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The macOS profiles to present when creating a new terminal via the terminal dropdown. When set, these will override the default detected profiles. They are comprised of a path and optional args.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.profiles.windows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The Windows profiles to present when creating a new terminal via the terminal dropdown. Set to null to exclude them, use the source property to use the default detected configuration. Or, set the path and optional args.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.rightClickBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls how terminal reacts to right click.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - default: Show the context menu.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - copyPaste: Copy when there is a selection, otherwise paste.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - paste: Paste on right click.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - selectWord: Select the word under the cursor and show the context menu.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.scrollback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls the maximum amount of lines the terminal keeps in its buffer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.sendKeybindingsToShell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dispatches most keybindings to the terminal instead of the workbench, overriding terminal.integrated.commandsToSkipShell, which can be used alternatively for fine tuning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.shell.linux
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is deprecated, the new recommended way to configure your default shell is by creating a terminal profile in terminal.integrated.profiles.linux# and setting its profile name as the default in #terminal.integrated.defaultProfile.linux. This will currently take priority over the new profiles settings but that will change in the future.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The path of the shell that the terminal uses on Linux. Read more about configuring the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.shell.osx
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is deprecated, the new recommended way to configure your default shell is by creating a terminal profile in terminal.integrated.profiles.osx# and setting its profile name as the default in #terminal.integrated.defaultProfile.osx. This will currently take priority over the new profiles settings but that will change in the future.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The path of the shell that the terminal uses on macOS. Read more about configuring the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.shell.windows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is deprecated, the new recommended way to configure your default shell is by creating a terminal profile in terminal.integrated.profiles.windows# and setting its profile name as the default in #terminal.integrated.defaultProfile.windows. This will currently take priority over the new profiles settings but that will change in the future.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The path of the shell that the terminal uses on Windows. Read more about configuring the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.shellArgs.linux
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is deprecated, the new recommended way to configure your default shell is by creating a terminal profile in terminal.integrated.profiles.linux# and setting its profile name as the default in #terminal.integrated.defaultProfile.linux. This will currently take priority over the new profiles settings but that will change in the future.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The command line arguments to use when on the Linux terminal. Read more about configuring the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.shellArgs.osx
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is deprecated, the new recommended way to configure your default shell is by creating a terminal profile in terminal.integrated.profiles.osx# and setting its profile name as the default in #terminal.integrated.defaultProfile.osx. This will currently take priority over the new profiles settings but that will change in the future.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The command line arguments to use when on the macOS terminal. Read more about configuring the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.shellArgs.windows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This is deprecated, the new recommended way to configure your default shell is by creating a terminal profile in terminal.integrated.profiles.windows# and setting its profile name as the default in #terminal.integrated.defaultProfile.windows. This will currently take priority over the new profiles settings but that will change in the future.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The command line arguments to use when on the Windows terminal. Read more about configuring the shell.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.showExitAlert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether to show the alert "The terminal process terminated with exit code" when exit code is non-zero.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.showLinkHover

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Whether to show hovers for links in the terminal output.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.splitCwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls the working directory a split terminal starts with.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - workspaceRoot: A new split terminal will use the workspace root as the working directory. In a multi-root workspace a choice for which root folder to use is offered.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - initial: A new split terminal will use the working directory that the parent terminal started with.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - inherited: On macOS and Linux, a new split terminal will use the working directory of the parent terminal. On Windows, this behaves the same as initial.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.tabs.enableAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls whether terminal tab statuses support animation (eg. in progress tasks).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.tabs.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether terminal tabs display as a list to the side of the terminal. When this is disabled a dropdown will display instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.tabs.focusMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether focusing the terminal of a tab happens on double or single click.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - singleClick: Focus the terminal when clicking a terminal tab
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          - doubleClick: Focus the terminal when double clicking a terminal tab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.tabs.hideCondition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Controls whether the terminal tabs view will hide under certain conditions.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - never: Never hide the terminal tabs view
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - singleTerminal: Hide the terminal tabs view when there is only a single terminal opened
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - singleGroup: Hide the terminal tabs view when there is only a single terminal group opened

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            terminal.integrated.tabs.location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Controls the location of the terminal tabs, either to the left or right of the actual terminal(s).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - left: Show the terminal tabs view to the left of the terminal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - right: Show the terminal tabs view to the right of the terminal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              terminal.integrated.tabs.showActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether terminal split and kill buttons are displays next to the new terminal button.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - always: Always show the actions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - singleTerminal: Show the actions when it is the only terminal opened
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - singleTerminalOrNarrow: Show the actions when it is the only terminal opened or when the tabs view is in its narrow textless state
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                - never: Never show the actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                terminal.integrated.tabs.showActiveTerminal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Shows the active terminal information in the view, this is particularly useful when the title within the tabs aren't visible.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - always: Always show the active terminal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - singleTerminal: Show the active terminal when it is the only terminal opened
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - singleTerminalOrNarrow: Show the active terminal when it is the only terminal opened or when the tabs view is in its narrow textless state
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  - never: Never show the active terminal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  terminal.integrated.titleMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Determines how the terminal's title is set, this shows up in the terminal's tab or dropdown entry.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - executable: The title is set by the terminal, the name of the detected foreground process will be used.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - sequence: The title is set by the process via an escape sequence, this is useful if your shell dynamically sets the title.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    terminal.integrated.unicodeVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls what version of unicode to use when evaluating the width of characters in the terminal. If you experience emoji or other wide characters not taking up the right amount of space or backspace either deleting too much or too little then you may want to try tweaking this setting.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - 6: Version 6 of unicode, this is an older version which should work better on older systems.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - 11: Version 11 of unicode, this version provides better support on modern systems that use modern versions of unicode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      terminal.integrated.useWslProfiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether or not WSL distros are shown in the terminal dropdown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        terminal.integrated.windowsEnableConpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Whether to use ConPTY for Windows terminal process communication (requires Windows 10 build number 18309+). Winpty will be used if this is false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          terminal.integrated.wordSeparators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A string containing all characters to be considered word separators by the double click to select word feature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            testing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            testing.automaticallyOpenPeekView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Configures when the error peek view is automatically opened.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - failureAnywhere: Open automatically no matter where the failure is.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - failureInVisibleDocument: Open automatically when a test fails in a visible document.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - never: Never automatically open.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              testing.automaticallyOpenPeekViewDuringAutoRun

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Controls whether to automatically open the peek view during auto-run mode.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                testing.autoRun.delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  How long to wait, in milliseconds, after a test is marked as outdated and starting a new run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  testing.autoRun.mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Controls which tests are automatically run.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - all: Automatically runs all discovered test when auto-run is toggled. Reruns individual tests when they are changed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - rerun: Reruns individual tests when they are changed. Will not automatically run any tests that have not been already executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    testing.defaultGutterClickAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Controls the action to take when left-clicking on a test decoration in the gutter.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - run: Run the test.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - debug: Debug the test.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      - contextMenu: Open the context menu for more options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      testing.followRunningTest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Controls whether the running test should be followed in the test explorer view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        testing.gutterEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Controls whether test decorations are shown in the editor gutter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timeline
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timeline.excludeSources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            An array of Timeline sources that should be excluded from the Timeline view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timeline.pageOnScroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Experimental. Controls whether the Timeline view will load the next page of items when you scroll to the end of the list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeline.pageSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The number of items to show in the Timeline view by default and when loading more items. Setting to null (the default) will automatically choose a page size based on the visible area of the Timeline view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typescript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typescript.autoClosingTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Enable/disable automatic closing of JSX tags.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typescript.check.npmIsInstalled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Check if npm is installed for Automatic Type Acquisition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript.disableAutomaticTypeAcquisition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Disables automatic type acquisition. Automatic type acquisition fetches @types packages from npm to improve IntelliSense for external libraries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript.enablePromptUseWorkspaceTsdk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Enables prompting of users to use the TypeScript version configured in the workspace for Intellisense.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typescript.format.enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Enable/disable default TypeScript formatter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typescript.format.insertSpaceAfterCommaDelimiter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines space handling after a comma delimiter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typescript.format.insertSpaceAfterConstructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines space handling after the constructor keyword.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typescript.format.insertSpaceAfterFunctionKeywordForAnonymousFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines space handling after function keyword for anonymous functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typescript.format.insertSpaceAfterKeywordsInControlFlowStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines space handling after keywords in a control flow statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typescript.format.insertSpaceAfterOpeningAndBeforeClosingEmptyBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines space handling after opening and before closing empty braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript.format.insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines space handling after opening and before closing JSX expression braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Defines space handling after opening and before closing non-empty braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines space handling after opening and before closing non-empty brackets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines space handling after opening and before closing non-empty parenthesis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typescript.format.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Defines space handling after opening and before closing template string braces.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typescript.format.insertSpaceAfterSemicolonInForStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Defines space handling after a semicolon in a for statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typescript.format.insertSpaceAfterTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Defines space handling after type assertions in TypeScript.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typescript.format.insertSpaceBeforeAndAfterBinaryOperators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Defines space handling after a binary operator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typescript.format.insertSpaceBeforeFunctionParenthesis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Defines space handling before function argument parentheses.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typescript.format.placeOpenBraceOnNewLineForControlBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Defines whether an open brace is put onto a new line for control blocks or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typescript.format.placeOpenBraceOnNewLineForFunctions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Defines whether an open brace is put onto a new line for functions or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typescript.format.semicolons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defines handling of optional semicolons. Requires using TypeScript 3.7 or newer in the workspace.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - ignore: Don't insert or remove any semicolons.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - insert: Insert semicolons at statement ends.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - remove: Remove unnecessary semicolons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typescript.implementationsCodeLens.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Enable/disable implementations CodeLens. This CodeLens shows the implementers of an interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typescript.inlayHints.enumMemberValues.enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enable/disable inlay hints for member values in enum declarations:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                `typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum MyValue {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A /* = 0 */;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                B /* = 1 */;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                `
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Requires using TypeScript 4.4+ in the workspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typescript.inlayHints.functionLikeReturnTypes.enabled