From adc0cacb18af275b3f0aa1d71a913a13253d5235 Mon Sep 17 00:00:00 2001 From: Allen7D <462870781@qq.com> Date: Fri, 26 Apr 2024 10:47:51 +0800 Subject: [PATCH] =?UTF-8?q?chore:=20=E5=9F=BA=E4=BA=8E=20obsidianmd/obsidi?= =?UTF-8?q?an-sample-plugin=20=E5=88=9D=E5=A7=8B=E5=8C=96=E9=A1=B9?= =?UTF-8?q?=E7=9B=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 1 + .prettierignore | 11 + .prettierrc | 7 + README.md | 97 +- esbuild.config.mjs | 56 +- main.css | 2395 +++++++++++++++++ manifest.json | 12 +- package.json | 14 +- src/SettingTab.ts | 31 + src/components/App/index.less | 3 + src/components/App/index.tsx | 13 + src/components/CodeEditorModal/CodeEditor.tsx | 133 + src/components/CodeEditorModal/index.tsx | 31 + main.ts => src/main.ts | 154 +- src/view.tsx | 39 + tsconfig.json | 39 +- yarn.lock | 1717 ++++++++++++ 17 files changed, 4523 insertions(+), 230 deletions(-) create mode 100644 .prettierignore create mode 100644 .prettierrc create mode 100644 main.css create mode 100644 src/SettingTab.ts create mode 100644 src/components/App/index.less create mode 100644 src/components/App/index.tsx create mode 100644 src/components/CodeEditorModal/CodeEditor.tsx create mode 100644 src/components/CodeEditorModal/index.tsx rename main.ts => src/main.ts (63%) create mode 100644 src/view.tsx create mode 100644 yarn.lock diff --git a/.gitignore b/.gitignore index e09a007..e9e68e4 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ node_modules # Don't include the compiled main.js file in the repo. # They should be uploaded to GitHub releases instead. main.js +dist # Exclude sourcemaps *.map diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..b4a79d2 --- /dev/null +++ b/.prettierignore @@ -0,0 +1,11 @@ +.DS_Store +package.json +/dist +.eslintignore +.editorconfig +.gitignore +.prettierignore +LICENSE +.eslintcache +*.lock +yarn-error.log diff --git a/.prettierrc b/.prettierrc new file mode 100644 index 0000000..6bd2473 --- /dev/null +++ b/.prettierrc @@ -0,0 +1,7 @@ +{ + "semi": true, + "printWidth": 120, + "tabWidth": 2, + "singleQuote": true, + "trailingComma": "all" +} \ No newline at end of file diff --git a/README.md b/README.md index bb0348e..92ffe5b 100644 --- a/README.md +++ b/README.md @@ -1,96 +1 @@ -# Obsidian Sample Plugin - -This is a sample plugin for Obsidian (https://obsidian.md). - -This project uses Typescript to provide type checking and documentation. -The repo depends on the latest plugin API (obsidian.d.ts) in Typescript Definition format, which contains TSDoc comments describing what it does. - -**Note:** The Obsidian API is still in early alpha and is subject to change at any time! - -This sample plugin demonstrates some of the basic functionality the plugin API can do. -- Adds a ribbon icon, which shows a Notice when clicked. -- Adds a command "Open Sample Modal" which opens a Modal. -- Adds a plugin setting tab to the settings page. -- Registers a global click event and output 'click' to the console. -- Registers a global interval which logs 'setInterval' to the console. - -## First time developing plugins? - -Quick starting guide for new plugin devs: - -- Check if [someone already developed a plugin for what you want](https://obsidian.md/plugins)! There might be an existing plugin similar enough that you can partner up with. -- Make a copy of this repo as a template with the "Use this template" button (login to GitHub if you don't see it). -- Clone your repo to a local development folder. For convenience, you can place this folder in your `.obsidian/plugins/your-plugin-name` folder. -- Install NodeJS, then run `npm i` in the command line under your repo folder. -- Run `npm run dev` to compile your plugin from `main.ts` to `main.js`. -- Make changes to `main.ts` (or create new `.ts` files). Those changes should be automatically compiled into `main.js`. -- Reload Obsidian to load the new version of your plugin. -- Enable plugin in settings window. -- For updates to the Obsidian API run `npm update` in the command line under your repo folder. - -## Releasing new releases - -- Update your `manifest.json` with your new version number, such as `1.0.1`, and the minimum Obsidian version required for your latest release. -- Update your `versions.json` file with `"new-plugin-version": "minimum-obsidian-version"` so older versions of Obsidian can download an older version of your plugin that's compatible. -- Create new GitHub release using your new version number as the "Tag version". Use the exact version number, don't include a prefix `v`. See here for an example: https://github.com/obsidianmd/obsidian-sample-plugin/releases -- Upload the files `manifest.json`, `main.js`, `styles.css` as binary attachments. Note: The manifest.json file must be in two places, first the root path of your repository and also in the release. -- Publish the release. - -> You can simplify the version bump process by running `npm version patch`, `npm version minor` or `npm version major` after updating `minAppVersion` manually in `manifest.json`. -> The command will bump version in `manifest.json` and `package.json`, and add the entry for the new version to `versions.json` - -## Adding your plugin to the community plugin list - -- Check https://github.com/obsidianmd/obsidian-releases/blob/master/plugin-review.md -- Publish an initial version. -- Make sure you have a `README.md` file in the root of your repo. -- Make a pull request at https://github.com/obsidianmd/obsidian-releases to add your plugin. - -## How to use - -- Clone this repo. -- Make sure your NodeJS is at least v16 (`node --version`). -- `npm i` or `yarn` to install dependencies. -- `npm run dev` to start compilation in watch mode. - -## Manually installing the plugin - -- Copy over `main.js`, `styles.css`, `manifest.json` to your vault `VaultFolder/.obsidian/plugins/your-plugin-id/`. - -## Improve code quality with eslint (optional) -- [ESLint](https://eslint.org/) is a tool that analyzes your code to quickly find problems. You can run ESLint against your plugin to find common bugs and ways to improve your code. -- To use eslint with this project, make sure to install eslint from terminal: - - `npm install -g eslint` -- To use eslint to analyze this project use this command: - - `eslint main.ts` - - eslint will then create a report with suggestions for code improvement by file and line number. -- If your source code is in a folder, such as `src`, you can use eslint with this command to analyze all files in that folder: - - `eslint .\src\` - -## Funding URL - -You can include funding URLs where people who use your plugin can financially support it. - -The simple way is to set the `fundingUrl` field to your link in your `manifest.json` file: - -```json -{ - "fundingUrl": "https://buymeacoffee.com" -} -``` - -If you have multiple URLs, you can also do: - -```json -{ - "fundingUrl": { - "Buy Me a Coffee": "https://buymeacoffee.com", - "GitHub Sponsor": "https://github.com/sponsors", - "Patreon": "https://www.patreon.com/" - } -} -``` - -## API Documentation - -See https://github.com/obsidianmd/obsidian-api +# Obsidian Code Editor diff --git a/esbuild.config.mjs b/esbuild.config.mjs index b13282b..1fb9904 100644 --- a/esbuild.config.mjs +++ b/esbuild.config.mjs @@ -1,43 +1,45 @@ -import esbuild from "esbuild"; -import process from "process"; -import builtins from "builtin-modules"; +import esbuild from 'esbuild'; +import process from 'process'; +import builtins from 'builtin-modules'; +import { lessLoader } from 'esbuild-plugin-less'; -const banner = -`/* +const banner = `/* THIS IS A GENERATED/BUNDLED FILE BY ESBUILD if you want to view the source, please visit the github repository of this plugin */ `; -const prod = (process.argv[2] === "production"); +const prod = process.argv[2] === 'production'; const context = await esbuild.context({ banner: { js: banner, }, - entryPoints: ["main.ts"], + entryPoints: ['src/main.ts'], bundle: true, external: [ - "obsidian", - "electron", - "@codemirror/autocomplete", - "@codemirror/collab", - "@codemirror/commands", - "@codemirror/language", - "@codemirror/lint", - "@codemirror/search", - "@codemirror/state", - "@codemirror/view", - "@lezer/common", - "@lezer/highlight", - "@lezer/lr", - ...builtins], - format: "cjs", - target: "es2018", - logLevel: "info", - sourcemap: prod ? false : "inline", + 'obsidian', + 'electron', + '@codemirror/autocomplete', + '@codemirror/collab', + '@codemirror/commands', + '@codemirror/language', + '@codemirror/lint', + '@codemirror/search', + '@codemirror/state', + '@codemirror/view', + '@lezer/common', + '@lezer/highlight', + '@lezer/lr', + ...builtins, + ], + format: 'cjs', + target: 'es2018', + logLevel: 'info', + sourcemap: prod ? false : 'inline', treeShaking: true, - outfile: "main.js", + outfile: 'main.js', + plugins: [lessLoader()], }); if (prod) { @@ -45,4 +47,4 @@ if (prod) { process.exit(0); } else { await context.watch(); -} \ No newline at end of file +} diff --git a/main.css b/main.css new file mode 100644 index 0000000..ab9b136 --- /dev/null +++ b/main.css @@ -0,0 +1,2395 @@ +/* src/components/App/index.less */ +.app-main { + color: red; +} + +/* node_modules/monaco-editor/esm/vs/editor/standalone/browser/standalone-tokens.css */ +.monaco-editor { + font-family: + -apple-system, + BlinkMacSystemFont, + "Segoe WPC", + "Segoe UI", + "HelveticaNeue-Light", + system-ui, + "Ubuntu", + "Droid Sans", + sans-serif; + --monaco-monospace-font: + "SF Mono", + Monaco, + Menlo, + Consolas, + "Ubuntu Mono", + "Liberation Mono", + "DejaVu Sans Mono", + "Courier New", + monospace; +} +.monaco-menu .monaco-action-bar.vertical .action-item .action-menu-item:focus .action-label { + stroke-width: 1.2px; +} +.monaco-editor.vs-dark .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label, +.monaco-editor.hc-black .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label, +.monaco-editor.hc-light .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label { + stroke-width: 1.2px; +} +.monaco-hover p { + margin: 0; +} +.monaco-aria-container { + position: absolute !important; + top: 0; + height: 1px; + width: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + clip: rect(1px, 1px, 1px, 1px); + clip-path: inset(50%); +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/aria/aria.css */ +.monaco-aria-container { + position: absolute; + left: -999em; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/widget/media/editor.css */ +::-ms-clear { + display: none; +} +.monaco-editor .editor-widget input { + color: inherit; +} +.monaco-editor { + position: relative; + overflow: visible; + -webkit-text-size-adjust: 100%; + color: var(--vscode-editor-foreground); + background-color: var(--vscode-editor-background); +} +.monaco-editor-background { + background-color: var(--vscode-editor-background); +} +.monaco-editor .rangeHighlight { + background-color: var(--vscode-editor-rangeHighlightBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-rangeHighlightBorder); +} +.monaco-editor.hc-black .rangeHighlight, +.monaco-editor.hc-light .rangeHighlight { + border-style: dotted; +} +.monaco-editor .symbolHighlight { + background-color: var(--vscode-editor-symbolHighlightBackground); + box-sizing: border-box; + border: 1px solid var(--vscode-editor-symbolHighlightBorder); +} +.monaco-editor.hc-black .symbolHighlight, +.monaco-editor.hc-light .symbolHighlight { + border-style: dotted; +} +.monaco-editor .overflow-guard { + position: relative; + overflow: hidden; +} +.monaco-editor .view-overlays { + position: absolute; + top: 0; +} +.monaco-editor .squiggly-error { + border-bottom: 4px double var(--vscode-editorError-border); +} +.monaco-editor .squiggly-error::before { + display: block; + content: ""; + width: 100%; + height: 100%; + background: var(--vscode-editorError-background); +} +.monaco-editor .squiggly-warning { + border-bottom: 4px double var(--vscode-editorWarning-border); +} +.monaco-editor .squiggly-warning::before { + display: block; + content: ""; + width: 100%; + height: 100%; + background: var(--vscode-editorWarning-background); +} +.monaco-editor .squiggly-info { + border-bottom: 4px double var(--vscode-editorInfo-border); +} +.monaco-editor .squiggly-info::before { + display: block; + content: ""; + width: 100%; + height: 100%; + background: var(--vscode-editorInfo-background); +} +.monaco-editor .squiggly-hint { + border-bottom: 2px dotted var(--vscode-editorHint-border); +} +.monaco-editor.showUnused .squiggly-unnecessary { + border-bottom: 2px dashed var(--vscode-editorUnnecessaryCode-border); +} +.monaco-editor.showDeprecated .squiggly-inline-deprecated { + text-decoration: line-through; + text-decoration-color: var(--vscode-editor-foreground, inherit); +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/scrollbar/media/scrollbars.css */ +.monaco-scrollable-element > .scrollbar > .scra { + cursor: pointer; + font-size: 11px !important; +} +.monaco-scrollable-element > .visible { + opacity: 1; + background: rgba(0, 0, 0, 0); + transition: opacity 100ms linear; + z-index: 11; +} +.monaco-scrollable-element > .invisible { + opacity: 0; + pointer-events: none; +} +.monaco-scrollable-element > .invisible.fade { + transition: opacity 800ms linear; +} +.monaco-scrollable-element > .shadow { + position: absolute; + display: none; +} +.monaco-scrollable-element > .shadow.top { + display: block; + top: 0; + left: 3px; + height: 3px; + width: 100%; + box-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset; +} +.monaco-scrollable-element > .shadow.left { + display: block; + top: 3px; + left: 0; + height: 100%; + width: 3px; + box-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset; +} +.monaco-scrollable-element > .shadow.top-left-corner { + display: block; + top: 0; + left: 0; + height: 3px; + width: 3px; +} +.monaco-scrollable-element > .shadow.top.left { + box-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset; +} +.monaco-scrollable-element > .scrollbar > .slider { + background: var(--vscode-scrollbarSlider-background); +} +.monaco-scrollable-element > .scrollbar > .slider:hover { + background: var(--vscode-scrollbarSlider-hoverBackground); +} +.monaco-scrollable-element > .scrollbar > .slider.active { + background: var(--vscode-scrollbarSlider-activeBackground); +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/controller/textAreaHandler.css */ +.monaco-editor .inputarea { + min-width: 0; + min-height: 0; + margin: 0; + padding: 0; + position: absolute; + outline: none !important; + resize: none; + border: none; + overflow: hidden; + color: transparent; + background-color: transparent; + z-index: -10; +} +.monaco-editor .inputarea.ime-input { + z-index: 10; + caret-color: var(--vscode-editorCursor-foreground); + color: var(--vscode-editor-foreground); +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lineNumbers/lineNumbers.css */ +.monaco-editor .margin-view-overlays .line-numbers { + font-variant-numeric: tabular-nums; + position: absolute; + text-align: right; + display: inline-block; + vertical-align: middle; + box-sizing: border-box; + cursor: default; + height: 100%; +} +.monaco-editor .relative-current-line-number { + text-align: left; + display: inline-block; + width: 100%; +} +.monaco-editor .margin-view-overlays .line-numbers.lh-odd { + margin-top: 1px; +} +.monaco-editor .line-numbers { + color: var(--vscode-editorLineNumber-foreground); +} +.monaco-editor .line-numbers.active-line-number { + color: var(--vscode-editorLineNumber-activeForeground); +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/margin/margin.css */ +.monaco-editor .margin { + background-color: var(--vscode-editorGutter-background); +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.css */ +.monaco-mouse-cursor-text { + cursor: text; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.css */ +.monaco-editor .view-overlays .current-line { + display: block; + position: absolute; + left: 0; + top: 0; + box-sizing: border-box; +} +.monaco-editor .margin-view-overlays .current-line { + display: block; + position: absolute; + left: 0; + top: 0; + box-sizing: border-box; +} +.monaco-editor .margin-view-overlays .current-line.current-line-margin.current-line-margin-both { + border-right: 0; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/decorations/decorations.css */ +.monaco-editor .lines-content .cdr { + position: absolute; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/indentGuides/indentGuides.css */ +.monaco-editor .lines-content .core-guide { + position: absolute; + box-sizing: border-box; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lines/viewLines.css */ +.mtkcontrol { + color: rgb(255, 255, 255) !important; + background: rgb(150, 0, 0) !important; +} +.mtkoverflow { + background-color: var(--vscode-button-background, var(--vscode-editor-background)); + color: var(--vscode-button-foreground, var(--vscode-editor-foreground)); + border-width: 1px; + border-style: solid; + border-color: var(--vscode-contrastBorder); + border-radius: 2px; + padding: 4px; + cursor: pointer; +} +.mtkoverflow:hover { + background-color: var(--vscode-button-hoverBackground); +} +.monaco-editor.no-user-select .lines-content, +.monaco-editor.no-user-select .view-line, +.monaco-editor.no-user-select .view-lines { + user-select: none; + -webkit-user-select: none; +} +.monaco-editor.mac .lines-content:hover, +.monaco-editor.mac .view-line:hover, +.monaco-editor.mac .view-lines:hover { + user-select: text; + -webkit-user-select: text; + -ms-user-select: text; +} +.monaco-editor.enable-user-select { + user-select: initial; + -webkit-user-select: initial; +} +.monaco-editor .view-lines { + white-space: nowrap; +} +.monaco-editor .view-line { + position: absolute; + width: 100%; +} +.monaco-editor .mtkw { + color: var(--vscode-editorWhitespace-foreground) !important; +} +.monaco-editor .mtkz { + display: inline-block; + color: var(--vscode-editorWhitespace-foreground) !important; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/linesDecorations/linesDecorations.css */ +.monaco-editor .lines-decorations { + position: absolute; + top: 0; + background: white; +} +.monaco-editor .margin-view-overlays .cldr { + position: absolute; + height: 100%; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/glyphMargin/glyphMargin.css */ +.monaco-editor .glyph-margin { + position: absolute; + top: 0; +} +.monaco-editor .glyph-margin-widgets .cgmr { + position: absolute; + display: flex; + align-items: center; + justify-content: center; +} +.monaco-editor .glyph-margin-widgets .cgmr.codicon-modifier-spin::before { + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -50%); +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/marginDecorations/marginDecorations.css */ +.monaco-editor .margin-view-overlays .cmdr { + position: absolute; + left: 0; + width: 100%; + height: 100%; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/minimap/minimap.css */ +.monaco-editor .minimap.slider-mouseover .minimap-slider { + opacity: 0; + transition: opacity 100ms linear; +} +.monaco-editor .minimap.slider-mouseover:hover .minimap-slider { + opacity: 1; +} +.monaco-editor .minimap.slider-mouseover .minimap-slider.active { + opacity: 1; +} +.monaco-editor .minimap-slider .minimap-slider-horizontal { + background: var(--vscode-minimapSlider-background); +} +.monaco-editor .minimap-slider:hover .minimap-slider-horizontal { + background: var(--vscode-minimapSlider-hoverBackground); +} +.monaco-editor .minimap-slider.active .minimap-slider-horizontal { + background: var(--vscode-minimapSlider-activeBackground); +} +.monaco-editor .minimap-shadow-visible { + box-shadow: var(--vscode-scrollbar-shadow) -6px 0 6px -6px inset; +} +.monaco-editor .minimap-shadow-hidden { + position: absolute; + width: 0; +} +.monaco-editor .minimap-shadow-visible { + position: absolute; + left: -6px; + width: 6px; +} +.monaco-editor.no-minimap-shadow .minimap-shadow-visible { + position: absolute; + left: -1px; + width: 1px; +} +.minimap.autohide { + opacity: 0; + transition: opacity 0.5s; +} +.minimap.autohide:hover { + opacity: 1; +} +.monaco-editor .minimap { + z-index: 5; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.css */ +.monaco-editor .overlayWidgets { + position: absolute; + top: 0; + left: 0; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/rulers/rulers.css */ +.monaco-editor .view-ruler { + position: absolute; + top: 0; + box-shadow: 1px 0 0 0 var(--vscode-editorRuler-foreground) inset; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.css */ +.monaco-editor .scroll-decoration { + position: absolute; + top: 0; + left: 0; + height: 6px; + box-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/selections/selections.css */ +.monaco-editor .lines-content .cslr { + position: absolute; +} +.monaco-editor .focused .selected-text { + background-color: var(--vscode-editor-selectionBackground); +} +.monaco-editor .selected-text { + background-color: var(--vscode-editor-inactiveSelectionBackground); +} +.monaco-editor .top-left-radius { + border-top-left-radius: 3px; +} +.monaco-editor .bottom-left-radius { + border-bottom-left-radius: 3px; +} +.monaco-editor .top-right-radius { + border-top-right-radius: 3px; +} +.monaco-editor .bottom-right-radius { + border-bottom-right-radius: 3px; +} +.monaco-editor.hc-black .top-left-radius { + border-top-left-radius: 0; +} +.monaco-editor.hc-black .bottom-left-radius { + border-bottom-left-radius: 0; +} +.monaco-editor.hc-black .top-right-radius { + border-top-right-radius: 0; +} +.monaco-editor.hc-black .bottom-right-radius { + border-bottom-right-radius: 0; +} +.monaco-editor.hc-light .top-left-radius { + border-top-left-radius: 0; +} +.monaco-editor.hc-light .bottom-left-radius { + border-bottom-left-radius: 0; +} +.monaco-editor.hc-light .top-right-radius { + border-top-right-radius: 0; +} +.monaco-editor.hc-light .bottom-right-radius { + border-bottom-right-radius: 0; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/viewCursors/viewCursors.css */ +.monaco-editor .cursors-layer { + position: absolute; + top: 0; +} +.monaco-editor .cursors-layer > .cursor { + position: absolute; + overflow: hidden; + box-sizing: border-box; +} +.monaco-editor .cursors-layer.cursor-smooth-caret-animation > .cursor { + transition: all 80ms; +} +.monaco-editor .cursors-layer.cursor-block-outline-style > .cursor { + background: transparent !important; + border-style: solid; + border-width: 1px; +} +.monaco-editor .cursors-layer.cursor-underline-style > .cursor { + border-bottom-width: 2px; + border-bottom-style: solid; + background: transparent !important; +} +.monaco-editor .cursors-layer.cursor-underline-thin-style > .cursor { + border-bottom-width: 1px; + border-bottom-style: solid; + background: transparent !important; +} +@keyframes monaco-cursor-smooth { + 0%, 20% { + opacity: 1; + } + 60%, 100% { + opacity: 0; + } +} +@keyframes monaco-cursor-phase { + 0%, 20% { + opacity: 1; + } + 90%, 100% { + opacity: 0; + } +} +@keyframes monaco-cursor-expand { + 0%, 20% { + transform: scaleY(1); + } + 80%, 100% { + transform: scaleY(0); + } +} +.cursor-smooth { + animation: monaco-cursor-smooth 0.5s ease-in-out 0s 20 alternate; +} +.cursor-phase { + animation: monaco-cursor-phase 0.5s ease-in-out 0s 20 alternate; +} +.cursor-expand > .cursor { + animation: monaco-cursor-expand 0.5s ease-in-out 0s 20 alternate; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/blockDecorations/blockDecorations.css */ +.monaco-editor .blockDecorations-container { + position: absolute; + top: 0; + pointer-events: none; +} +.monaco-editor .blockDecorations-block { + position: absolute; + box-sizing: border-box; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/viewParts/whitespace/whitespace.css */ +.monaco-editor .mwh { + position: absolute; + color: var(--vscode-editorWhitespace-foreground) !important; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/contextview/contextview.css */ +.context-view { + position: absolute; +} +.context-view.fixed { + all: initial; + font-family: inherit; + font-size: 13px; + position: fixed; + color: inherit; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/list/list.css */ +.monaco-list { + position: relative; + height: 100%; + width: 100%; + white-space: nowrap; +} +.monaco-list.mouse-support { + user-select: none; + -webkit-user-select: none; +} +.monaco-list > .monaco-scrollable-element { + height: 100%; +} +.monaco-list-rows { + position: relative; + width: 100%; + height: 100%; +} +.monaco-list.horizontal-scrolling .monaco-list-rows { + width: auto; + min-width: 100%; +} +.monaco-list-row { + position: absolute; + box-sizing: border-box; + overflow: hidden; + width: 100%; +} +.monaco-list.mouse-support .monaco-list-row { + cursor: pointer; + touch-action: none; +} +.monaco-list-row.scrolling { + display: none !important; +} +.monaco-list.element-focused, +.monaco-list.selection-single, +.monaco-list.selection-multiple { + outline: 0 !important; +} +.monaco-drag-image { + display: inline-block; + padding: 1px 7px; + border-radius: 10px; + font-size: 12px; + position: absolute; + z-index: 1000; +} +.monaco-list-type-filter-message { + position: absolute; + box-sizing: border-box; + width: 100%; + height: 100%; + top: 0; + left: 0; + padding: 40px 1em 1em 1em; + text-align: center; + white-space: normal; + opacity: 0.7; + pointer-events: none; +} +.monaco-list-type-filter-message:empty { + display: none; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBoxCustom.css */ +.monaco-select-box-dropdown-padding { + --dropdown-padding-top: 1px; + --dropdown-padding-bottom: 1px; +} +.hc-black .monaco-select-box-dropdown-padding, +.hc-light .monaco-select-box-dropdown-padding { + --dropdown-padding-top: 3px; + --dropdown-padding-bottom: 4px; +} +.monaco-select-box-dropdown-container { + display: none; + box-sizing: border-box; +} +.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown * { + margin: 0; +} +.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown a:focus { + outline: 1px solid -webkit-focus-ring-color; + outline-offset: -1px; +} +.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown code { + line-height: 15px; + font-family: var(--monaco-monospace-font); +} +.monaco-select-box-dropdown-container.visible { + display: flex; + flex-direction: column; + text-align: left; + width: 1px; + overflow: hidden; + border-bottom-left-radius: 3px; + border-bottom-right-radius: 3px; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container { + flex: 0 0 auto; + align-self: flex-start; + padding-top: var(--dropdown-padding-top); + padding-bottom: var(--dropdown-padding-bottom); + padding-left: 1px; + padding-right: 1px; + width: 100%; + overflow: hidden; + box-sizing: border-box; +} +.monaco-select-box-dropdown-container > .select-box-details-pane { + padding: 5px; +} +.hc-black .monaco-select-box-dropdown-container > .select-box-dropdown-list-container { + padding-top: var(--dropdown-padding-top); + padding-bottom: var(--dropdown-padding-bottom); +} +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row { + cursor: pointer; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-text { + text-overflow: ellipsis; + overflow: hidden; + padding-left: 3.5px; + white-space: nowrap; + float: left; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-detail { + text-overflow: ellipsis; + overflow: hidden; + padding-left: 3.5px; + white-space: nowrap; + float: left; + opacity: 0.7; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-decorator-right { + text-overflow: ellipsis; + overflow: hidden; + padding-right: 10px; + white-space: nowrap; + float: right; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .visually-hidden { + position: absolute; + left: -10000px; + top: auto; + width: 1px; + height: 1px; + overflow: hidden; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control { + flex: 1 1 auto; + align-self: flex-start; + opacity: 0; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div { + overflow: hidden; + max-height: 0px; +} +.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div > .option-text-width-control { + padding-left: 4px; + padding-right: 8px; + white-space: nowrap; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.css */ +.monaco-select-box { + width: 100%; + cursor: pointer; + border-radius: 2px; +} +.monaco-select-box-dropdown-container { + font-size: 13px; + font-weight: normal; + text-transform: none; +} +.monaco-action-bar .action-item.select-container { + cursor: default; +} +.monaco-action-bar .action-item .monaco-select-box { + cursor: pointer; + min-width: 100px; + min-height: 18px; + padding: 2px 23px 2px 8px; +} +.mac .monaco-action-bar .action-item .monaco-select-box { + font-size: 11px; + border-radius: 5px; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.css */ +.monaco-action-bar { + white-space: nowrap; + height: 100%; +} +.monaco-action-bar .actions-container { + display: flex; + margin: 0 auto; + padding: 0; + height: 100%; + width: 100%; + align-items: center; +} +.monaco-action-bar.vertical .actions-container { + display: inline-block; +} +.monaco-action-bar .action-item { + display: block; + align-items: center; + justify-content: center; + cursor: pointer; + position: relative; +} +.monaco-action-bar .action-item.disabled { + cursor: default; +} +.monaco-action-bar .action-item .icon, +.monaco-action-bar .action-item .codicon { + display: block; +} +.monaco-action-bar .action-item .codicon { + display: flex; + align-items: center; + width: 16px; + height: 16px; +} +.monaco-action-bar .action-label { + display: flex; + font-size: 11px; + padding: 3px; + border-radius: 5px; +} +.monaco-action-bar .action-item.disabled .action-label, +.monaco-action-bar .action-item.disabled .action-label::before, +.monaco-action-bar .action-item.disabled .action-label:hover { + opacity: 0.6; +} +.monaco-action-bar.vertical { + text-align: left; +} +.monaco-action-bar.vertical .action-item { + display: block; +} +.monaco-action-bar.vertical .action-label.separator { + display: block; + border-bottom: 1px solid #bbb; + padding-top: 1px; + margin-left: .8em; + margin-right: .8em; +} +.monaco-action-bar .action-item .action-label.separator { + width: 1px; + height: 16px; + margin: 5px 4px !important; + cursor: default; + min-width: 1px; + padding: 0; + background-color: #bbb; +} +.secondary-actions .monaco-action-bar .action-label { + margin-left: 6px; +} +.monaco-action-bar .action-item.select-container { + overflow: hidden; + flex: 1; + max-width: 170px; + min-width: 60px; + display: flex; + align-items: center; + justify-content: center; + margin-right: 10px; +} +.monaco-action-bar .action-item.action-dropdown-item { + display: flex; +} +.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator { + display: flex; + align-items: center; + cursor: default; +} +.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator > div { + width: 1px; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/dropdown/dropdown.css */ +.monaco-dropdown { + height: 100%; + padding: 0; +} +.monaco-dropdown > .dropdown-label { + cursor: pointer; + height: 100%; + display: flex; + align-items: center; + justify-content: center; +} +.monaco-dropdown > .dropdown-label > .action-label.disabled { + cursor: default; +} +.monaco-dropdown-with-primary { + display: flex !important; + flex-direction: row; + border-radius: 5px; +} +.monaco-dropdown-with-primary > .action-container > .action-label { + margin-right: 0; +} +.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*=codicon-] { + font-size: 12px; + padding-left: 0px; + padding-right: 0px; + line-height: 16px; + margin-left: -3px; +} +.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label { + display: block; + background-size: 16px; + background-position: center center; + background-repeat: no-repeat; +} + +/* node_modules/monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.css */ +.monaco-action-bar .action-item.menu-entry .action-label.icon { + width: 16px; + height: 16px; + background-repeat: no-repeat; + background-position: 50%; + background-size: 16px; +} +.monaco-dropdown-with-default { + display: flex !important; + flex-direction: row; + border-radius: 5px; +} +.monaco-dropdown-with-default > .action-container > .action-label { + margin-right: 0; +} +.monaco-dropdown-with-default > .action-container.menu-entry > .action-label.icon { + width: 16px; + height: 16px; + background-repeat: no-repeat; + background-position: 50%; + background-size: 16px; +} +.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*=codicon-] { + font-size: 12px; + padding-left: 0px; + padding-right: 0px; + line-height: 16px; + margin-left: -3px; +} +.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label { + display: block; + background-size: 16px; + background-position: center center; + background-repeat: no-repeat; +} + +/* node_modules/monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInput.css */ +.quick-input-widget { + font-size: 13px; +} +.quick-input-widget .monaco-highlighted-label .highlight, +.quick-input-widget .monaco-highlighted-label .highlight { + color: #0066BF; +} +.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight, +.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight { + color: #9DDDFF; +} +.vs-dark .quick-input-widget .monaco-highlighted-label .highlight, +.vs-dark .quick-input-widget .monaco-highlighted-label .highlight { + color: #0097fb; +} +.hc-black .quick-input-widget .monaco-highlighted-label .highlight, +.hc-black .quick-input-widget .monaco-highlighted-label .highlight { + color: #F38518; +} +.hc-light .quick-input-widget .monaco-highlighted-label .highlight, +.hc-light .quick-input-widget .monaco-highlighted-label .highlight { + color: #0F4A85; +} +.monaco-keybinding > .monaco-keybinding-key { + background-color: rgba(221, 221, 221, 0.4); + border: solid 1px rgba(204, 204, 204, 0.4); + border-bottom-color: rgba(187, 187, 187, 0.4); + box-shadow: inset 0 -1px 0 rgba(187, 187, 187, 0.4); + color: #555; +} +.hc-black .monaco-keybinding > .monaco-keybinding-key { + background-color: transparent; + border: solid 1px rgb(111, 195, 223); + box-shadow: none; + color: #fff; +} +.hc-light .monaco-keybinding > .monaco-keybinding-key { + background-color: transparent; + border: solid 1px #0F4A85; + box-shadow: none; + color: #292929; +} +.vs-dark .monaco-keybinding > .monaco-keybinding-key { + background-color: rgba(128, 128, 128, 0.17); + border: solid 1px rgba(51, 51, 51, 0.6); + border-bottom-color: rgba(68, 68, 68, 0.6); + box-shadow: inset 0 -1px 0 rgba(68, 68, 68, 0.6); + color: #ccc; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/sash/sash.css */ +:root { + --vscode-sash-size: 4px; + --vscode-sash-hover-size: 4px; +} +.monaco-sash { + position: absolute; + z-index: 35; + touch-action: none; +} +.monaco-sash.disabled { + pointer-events: none; +} +.monaco-sash.mac.vertical { + cursor: col-resize; +} +.monaco-sash.vertical.minimum { + cursor: e-resize; +} +.monaco-sash.vertical.maximum { + cursor: w-resize; +} +.monaco-sash.mac.horizontal { + cursor: row-resize; +} +.monaco-sash.horizontal.minimum { + cursor: s-resize; +} +.monaco-sash.horizontal.maximum { + cursor: n-resize; +} +.monaco-sash.disabled { + cursor: default !important; + pointer-events: none !important; +} +.monaco-sash.vertical { + cursor: ew-resize; + top: 0; + width: var(--vscode-sash-size); + height: 100%; +} +.monaco-sash.horizontal { + cursor: ns-resize; + left: 0; + width: 100%; + height: var(--vscode-sash-size); +} +.monaco-sash:not(.disabled) > .orthogonal-drag-handle { + content: " "; + height: calc(var(--vscode-sash-size) * 2); + width: calc(var(--vscode-sash-size) * 2); + z-index: 100; + display: block; + cursor: all-scroll; + position: absolute; +} +.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled) > .orthogonal-drag-handle.start, +.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled) > .orthogonal-drag-handle.end { + cursor: nwse-resize; +} +.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled) > .orthogonal-drag-handle.end, +.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled) > .orthogonal-drag-handle.start { + cursor: nesw-resize; +} +.monaco-sash.vertical > .orthogonal-drag-handle.start { + left: calc(var(--vscode-sash-size) * -0.5); + top: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash.vertical > .orthogonal-drag-handle.end { + left: calc(var(--vscode-sash-size) * -0.5); + bottom: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash.horizontal > .orthogonal-drag-handle.start { + top: calc(var(--vscode-sash-size) * -0.5); + left: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash.horizontal > .orthogonal-drag-handle.end { + top: calc(var(--vscode-sash-size) * -0.5); + right: calc(var(--vscode-sash-size) * -1); +} +.monaco-sash:before { + content: ""; + pointer-events: none; + position: absolute; + width: 100%; + height: 100%; + background: transparent; +} +.monaco-workbench:not(.reduce-motion) .monaco-sash:before { + transition: background-color 0.1s ease-out; +} +.monaco-sash.hover:before, +.monaco-sash.active:before { + background: var(--vscode-sash-hoverBorder); +} +.monaco-sash.vertical:before { + width: var(--vscode-sash-hover-size); + left: calc(50% - (var(--vscode-sash-hover-size) / 2)); +} +.monaco-sash.horizontal:before { + height: var(--vscode-sash-hover-size); + top: calc(50% - (var(--vscode-sash-hover-size) / 2)); +} +.pointer-events-disabled { + pointer-events: none !important; +} +.monaco-sash.debug { + background: cyan; +} +.monaco-sash.debug.disabled { + background: rgba(0, 255, 255, 0.2); +} +.monaco-sash.debug:not(.disabled) > .orthogonal-drag-handle { + background: red; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/splitview/splitview.css */ +.monaco-split-view2 { + position: relative; + width: 100%; + height: 100%; +} +.monaco-split-view2 > .sash-container { + position: absolute; + width: 100%; + height: 100%; + pointer-events: none; +} +.monaco-split-view2 > .sash-container > .monaco-sash { + pointer-events: initial; +} +.monaco-split-view2 > .monaco-scrollable-element { + width: 100%; + height: 100%; +} +.monaco-split-view2 > .monaco-scrollable-element > .split-view-container { + width: 100%; + height: 100%; + white-space: nowrap; + position: relative; +} +.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view { + white-space: initial; + position: absolute; +} +.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view:not(.visible) { + display: none; +} +.monaco-split-view2.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view { + width: 100%; +} +.monaco-split-view2.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view { + height: 100%; +} +.monaco-split-view2.separator-border > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before { + content: " "; + position: absolute; + top: 0; + left: 0; + z-index: 5; + pointer-events: none; + background-color: var(--separator-border); +} +.monaco-split-view2.separator-border.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before { + height: 100%; + width: 1px; +} +.monaco-split-view2.separator-border.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before { + height: 1px; + width: 100%; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/table/table.css */ +.monaco-table { + display: flex; + flex-direction: column; + position: relative; + height: 100%; + width: 100%; + white-space: nowrap; + overflow: hidden; +} +.monaco-table > .monaco-split-view2 { + border-bottom: 1px solid transparent; +} +.monaco-table > .monaco-list { + flex: 1; +} +.monaco-table-tr { + display: flex; + height: 100%; +} +.monaco-table-th { + width: 100%; + height: 100%; + font-weight: bold; + overflow: hidden; + text-overflow: ellipsis; +} +.monaco-table-th, +.monaco-table-td { + box-sizing: border-box; + flex-shrink: 0; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} +.monaco-table > .monaco-split-view2 .monaco-sash.vertical::before { + content: ""; + position: absolute; + left: calc(var(--vscode-sash-size) / 2); + width: 0; + border-left: 1px solid transparent; +} +.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2, +.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2 .monaco-sash.vertical::before { + transition: border-color 0.2s ease-out; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/toggle/toggle.css */ +.monaco-custom-toggle { + margin-left: 2px; + float: left; + cursor: pointer; + overflow: hidden; + width: 20px; + height: 20px; + border-radius: 3px; + border: 1px solid transparent; + padding: 1px; + box-sizing: border-box; + user-select: none; + -webkit-user-select: none; +} +.monaco-custom-toggle:hover { + background-color: var(--vscode-inputOption-hoverBackground); +} +.hc-black .monaco-custom-toggle:hover, +.hc-light .monaco-custom-toggle:hover { + border: 1px dashed var(--vscode-focusBorder); +} +.hc-black .monaco-custom-toggle, +.hc-light .monaco-custom-toggle { + background: none; +} +.hc-black .monaco-custom-toggle:hover, +.hc-light .monaco-custom-toggle:hover { + background: none; +} +.monaco-custom-toggle.monaco-checkbox { + height: 18px; + width: 18px; + border: 1px solid transparent; + border-radius: 3px; + margin-right: 9px; + margin-left: 0px; + padding: 0px; + opacity: 1; + background-size: 16px !important; +} +.monaco-custom-toggle.monaco-checkbox:not(.checked)::before { + visibility: hidden; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.css */ +.monaco-inputbox { + position: relative; + display: block; + padding: 0; + box-sizing: border-box; + border-radius: 2px; + font-size: inherit; +} +.monaco-inputbox > .ibwrapper > .input, +.monaco-inputbox > .ibwrapper > .mirror { + padding: 4px 6px; +} +.monaco-inputbox > .ibwrapper { + position: relative; + width: 100%; + height: 100%; +} +.monaco-inputbox > .ibwrapper > .input { + display: inline-block; + box-sizing: border-box; + width: 100%; + height: 100%; + line-height: inherit; + border: none; + font-family: inherit; + font-size: inherit; + resize: none; + color: inherit; +} +.monaco-inputbox > .ibwrapper > input { + text-overflow: ellipsis; +} +.monaco-inputbox > .ibwrapper > textarea.input { + display: block; + scrollbar-width: none; + outline: none; +} +.monaco-inputbox > .ibwrapper > textarea.input::-webkit-scrollbar { + display: none; +} +.monaco-inputbox > .ibwrapper > textarea.input.empty { + white-space: nowrap; +} +.monaco-inputbox > .ibwrapper > .mirror { + position: absolute; + display: inline-block; + width: 100%; + top: 0; + left: 0; + box-sizing: border-box; + white-space: pre-wrap; + visibility: hidden; + word-wrap: break-word; +} +.monaco-inputbox-container { + text-align: right; +} +.monaco-inputbox-container .monaco-inputbox-message { + display: inline-block; + overflow: hidden; + text-align: left; + width: 100%; + box-sizing: border-box; + padding: 0.4em; + font-size: 12px; + line-height: 17px; + margin-top: -1px; + word-wrap: break-word; +} +.monaco-inputbox .monaco-action-bar { + position: absolute; + right: 2px; + top: 4px; +} +.monaco-inputbox .monaco-action-bar .action-item { + margin-left: 2px; +} +.monaco-inputbox .monaco-action-bar .action-item .codicon { + background-repeat: no-repeat; + width: 16px; + height: 16px; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/findinput/findInput.css */ +.monaco-findInput { + position: relative; +} +.monaco-findInput .monaco-inputbox { + font-size: 13px; + width: 100%; +} +.monaco-findInput > .controls { + position: absolute; + top: 3px; + right: 2px; +} +.vs .monaco-findInput.disabled { + background-color: #E1E1E1; +} +.vs-dark .monaco-findInput.disabled { + background-color: #333; +} +.monaco-findInput.highlight-0 .controls, +.hc-light .monaco-findInput.highlight-0 .controls { + animation: monaco-findInput-highlight-0 100ms linear 0s; +} +.monaco-findInput.highlight-1 .controls, +.hc-light .monaco-findInput.highlight-1 .controls { + animation: monaco-findInput-highlight-1 100ms linear 0s; +} +.hc-black .monaco-findInput.highlight-0 .controls, +.vs-dark .monaco-findInput.highlight-0 .controls { + animation: monaco-findInput-highlight-dark-0 100ms linear 0s; +} +.hc-black .monaco-findInput.highlight-1 .controls, +.vs-dark .monaco-findInput.highlight-1 .controls { + animation: monaco-findInput-highlight-dark-1 100ms linear 0s; +} +@keyframes monaco-findInput-highlight-0 { + 0% { + background: rgba(253, 255, 0, 0.8); + } + 100% { + background: transparent; + } +} +@keyframes monaco-findInput-highlight-1 { + 0% { + background: rgba(253, 255, 0, 0.8); + } + 99% { + background: transparent; + } +} +@keyframes monaco-findInput-highlight-dark-0 { + 0% { + background: rgba(255, 255, 255, 0.44); + } + 100% { + background: transparent; + } +} +@keyframes monaco-findInput-highlight-dark-1 { + 0% { + background: rgba(255, 255, 255, 0.44); + } + 99% { + background: transparent; + } +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/tree/media/tree.css */ +.monaco-tl-row { + display: flex; + height: 100%; + align-items: center; + position: relative; +} +.monaco-tl-row.disabled { + cursor: default; +} +.monaco-tl-indent { + height: 100%; + position: absolute; + top: 0; + left: 16px; + pointer-events: none; +} +.hide-arrows .monaco-tl-indent { + left: 12px; +} +.monaco-tl-indent > .indent-guide { + display: inline-block; + box-sizing: border-box; + height: 100%; + border-left: 1px solid transparent; +} +.monaco-workbench:not(.reduce-motion) .monaco-tl-indent > .indent-guide { + transition: border-color 0.1s linear; +} +.monaco-tl-twistie, +.monaco-tl-contents { + height: 100%; +} +.monaco-tl-twistie { + font-size: 10px; + text-align: right; + padding-right: 6px; + flex-shrink: 0; + width: 16px; + display: flex !important; + align-items: center; + justify-content: center; + transform: translateX(3px); +} +.monaco-tl-contents { + flex: 1; + overflow: hidden; +} +.monaco-tl-twistie::before { + border-radius: 20px; +} +.monaco-tl-twistie.collapsed::before { + transform: rotate(-90deg); +} +.monaco-tl-twistie.codicon-tree-item-loading::before { + animation: codicon-spin 1.25s steps(30) infinite; +} +.monaco-tree-type-filter { + position: absolute; + top: 0; + display: flex; + padding: 3px; + max-width: 200px; + z-index: 100; + margin: 0 6px; + border: 1px solid var(--vscode-widget-border); + border-bottom-left-radius: 4px; + border-bottom-right-radius: 4px; +} +.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter { + transition: top 0.3s; +} +.monaco-tree-type-filter.disabled { + top: -40px !important; +} +.monaco-tree-type-filter-grab { + display: flex !important; + align-items: center; + justify-content: center; + cursor: grab; + margin-right: 2px; +} +.monaco-tree-type-filter-grab.grabbing { + cursor: grabbing; +} +.monaco-tree-type-filter-input { + flex: 1; +} +.monaco-tree-type-filter-input .monaco-inputbox { + height: 23px; +} +.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .input, +.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .mirror { + padding: 2px 4px; +} +.monaco-tree-type-filter-input .monaco-findInput > .controls { + top: 2px; +} +.monaco-tree-type-filter-actionbar { + margin-left: 4px; +} +.monaco-tree-type-filter-actionbar .monaco-action-bar .action-label { + padding: 2px; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/button/button.css */ +.monaco-text-button { + box-sizing: border-box; + display: flex; + width: 100%; + padding: 4px; + border-radius: 2px; + text-align: center; + cursor: pointer; + justify-content: center; + align-items: center; + border: 1px solid var(--vscode-button-border, transparent); + line-height: 18px; +} +.monaco-text-button:focus { + outline-offset: 2px !important; +} +.monaco-text-button:hover { + text-decoration: none !important; +} +.monaco-button.disabled:focus, +.monaco-button.disabled { + opacity: 0.4 !important; + cursor: default; +} +.monaco-text-button .codicon { + margin: 0 0.2em; + color: inherit !important; +} +.monaco-text-button.monaco-text-button-with-short-label { + flex-direction: row; + flex-wrap: wrap; + padding: 0 4px; + overflow: hidden; + height: 28px; +} +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label { + flex-basis: 100%; +} +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short { + flex-grow: 1; + width: 0; + overflow: hidden; +} +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label, +.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short { + display: flex; + justify-content: center; + align-items: center; + font-weight: normal; + font-style: inherit; + padding: 4px 0; +} +.monaco-button-dropdown { + display: flex; + cursor: pointer; +} +.monaco-button-dropdown.disabled { + cursor: default; +} +.monaco-button-dropdown > .monaco-button:focus { + outline-offset: -1px !important; +} +.monaco-button-dropdown.disabled > .monaco-button.disabled, +.monaco-button-dropdown.disabled > .monaco-button.disabled:focus, +.monaco-button-dropdown.disabled > .monaco-button-dropdown-separator { + opacity: 0.4 !important; +} +.monaco-button-dropdown > .monaco-button.monaco-text-button { + border-right-width: 0 !important; +} +.monaco-button-dropdown .monaco-button-dropdown-separator { + padding: 4px 0; + cursor: default; +} +.monaco-button-dropdown .monaco-button-dropdown-separator > div { + height: 100%; + width: 1px; +} +.monaco-button-dropdown > .monaco-button.monaco-dropdown-button { + border: 1px solid var(--vscode-button-border, transparent); + border-left-width: 0 !important; + border-radius: 0 2px 2px 0; +} +.monaco-button-dropdown > .monaco-button.monaco-text-button { + border-radius: 2px 0 0 2px; +} +.monaco-description-button { + display: flex; + flex-direction: column; + align-items: center; + margin: 4px 5px; +} +.monaco-description-button .monaco-button-description { + font-style: italic; + font-size: 11px; + padding: 4px 20px; +} +.monaco-description-button .monaco-button-label, +.monaco-description-button .monaco-button-description { + display: flex; + justify-content: center; + align-items: center; +} +.monaco-description-button .monaco-button-label > .codicon, +.monaco-description-button .monaco-button-description > .codicon { + margin: 0 0.2em; + color: inherit !important; +} +.monaco-button.default-colors, +.monaco-button-dropdown.default-colors > .monaco-button { + color: var(--vscode-button-foreground); + background-color: var(--vscode-button-background); +} +.monaco-button.default-colors:hover, +.monaco-button-dropdown.default-colors > .monaco-button:hover { + background-color: var(--vscode-button-hoverBackground); +} +.monaco-button.default-colors.secondary, +.monaco-button-dropdown.default-colors > .monaco-button.secondary { + color: var(--vscode-button-secondaryForeground); + background-color: var(--vscode-button-secondaryBackground); +} +.monaco-button.default-colors.secondary:hover, +.monaco-button-dropdown.default-colors > .monaco-button.secondary:hover { + background-color: var(--vscode-button-secondaryHoverBackground); +} +.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator { + background-color: var(--vscode-button-background); + border-top: 1px solid var(--vscode-button-border); + border-bottom: 1px solid var(--vscode-button-border); +} +.monaco-button-dropdown.default-colors .monaco-button.secondary + .monaco-button-dropdown-separator { + background-color: var(--vscode-button-secondaryBackground); +} +.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator > div { + background-color: var(--vscode-button-separator); +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.css */ +.monaco-count-badge { + padding: 3px 6px; + border-radius: 11px; + font-size: 11px; + min-width: 18px; + min-height: 18px; + line-height: 11px; + font-weight: normal; + text-align: center; + display: inline-block; + box-sizing: border-box; +} +.monaco-count-badge.long { + padding: 2px 3px; + border-radius: 2px; + min-height: auto; + line-height: normal; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.css */ +.monaco-progress-container { + width: 100%; + height: 5px; + overflow: hidden; +} +.monaco-progress-container .progress-bit { + width: 2%; + height: 5px; + position: absolute; + left: 0; + display: none; +} +.monaco-progress-container.active .progress-bit { + display: inherit; +} +.monaco-progress-container.discrete .progress-bit { + left: 0; + transition: width 100ms linear; +} +.monaco-progress-container.discrete.done .progress-bit { + width: 100%; +} +.monaco-progress-container.infinite .progress-bit { + animation-name: progress; + animation-duration: 4s; + animation-iteration-count: infinite; + transform: translate3d(0px, 0px, 0px); + animation-timing-function: linear; +} +.monaco-progress-container.infinite.infinite-long-running .progress-bit { + animation-timing-function: steps(100); +} +@keyframes progress { + from { + transform: translateX(0%) scaleX(1); + } + 50% { + transform: translateX(2500%) scaleX(3); + } + to { + transform: translateX(4900%) scaleX(1); + } +} + +/* node_modules/monaco-editor/esm/vs/platform/quickinput/browser/media/quickInput.css */ +.quick-input-widget { + position: absolute; + width: 600px; + z-index: 2550; + left: 50%; + margin-left: -300px; + -webkit-app-region: no-drag; + border-radius: 6px; +} +.quick-input-titlebar { + display: flex; + align-items: center; + border-top-left-radius: 5px; + border-top-right-radius: 5px; +} +.quick-input-left-action-bar { + display: flex; + margin-left: 4px; + flex: 1; +} +.quick-input-title { + padding: 3px 0px; + text-align: center; + text-overflow: ellipsis; + overflow: hidden; +} +.quick-input-right-action-bar { + display: flex; + margin-right: 4px; + flex: 1; +} +.quick-input-right-action-bar > .actions-container { + justify-content: flex-end; +} +.quick-input-titlebar .monaco-action-bar .action-label.codicon { + background-position: center; + background-repeat: no-repeat; + padding: 2px; +} +.quick-input-description { + margin: 6px 6px 6px 11px; +} +.quick-input-header .quick-input-description { + margin: 4px 2px; + flex: 1; +} +.quick-input-header { + display: flex; + padding: 8px 6px 6px 6px; +} +.quick-input-widget.hidden-input .quick-input-header { + padding: 0; + margin-bottom: 0; +} +.quick-input-and-message { + display: flex; + flex-direction: column; + flex-grow: 1; + min-width: 0; + position: relative; +} +.quick-input-check-all { + align-self: center; + margin: 0; +} +.quick-input-filter { + flex-grow: 1; + display: flex; + position: relative; +} +.quick-input-box { + flex-grow: 1; +} +.quick-input-widget.show-checkboxes .quick-input-box, +.quick-input-widget.show-checkboxes .quick-input-message { + margin-left: 5px; +} +.quick-input-visible-count { + position: absolute; + left: -10000px; +} +.quick-input-count { + align-self: center; + position: absolute; + right: 4px; + display: flex; + align-items: center; +} +.quick-input-count .monaco-count-badge { + vertical-align: middle; + padding: 2px 4px; + border-radius: 2px; + min-height: auto; + line-height: normal; +} +.quick-input-action { + margin-left: 6px; +} +.quick-input-action .monaco-text-button { + font-size: 11px; + padding: 0 6px; + display: flex; + height: 25px; + align-items: center; +} +.quick-input-message { + margin-top: -1px; + padding: 5px; + overflow-wrap: break-word; +} +.quick-input-message > .codicon { + margin: 0 0.2em; + vertical-align: text-bottom; +} +.quick-input-message a { + color: inherit; +} +.quick-input-progress.monaco-progress-container { + position: relative; +} +.quick-input-progress.monaco-progress-container, +.quick-input-progress.monaco-progress-container .progress-bit { + height: 2px; +} +.quick-input-list { + line-height: 22px; +} +.quick-input-widget.hidden-input .quick-input-list { + margin-top: 4px; + padding-bottom: 4px; +} +.quick-input-list .monaco-list { + overflow: hidden; + max-height: calc(20 * 22px); + padding-bottom: 5px; +} +.quick-input-list .monaco-scrollable-element { + padding: 0px 5px; +} +.quick-input-list .quick-input-list-entry { + box-sizing: border-box; + overflow: hidden; + display: flex; + height: 100%; + padding: 0 6px; +} +.quick-input-list .quick-input-list-entry.quick-input-list-separator-border { + border-top-width: 1px; + border-top-style: solid; +} +.quick-input-list .monaco-list-row { + border-radius: 3px; +} +.quick-input-list .monaco-list-row[data-index="0"] .quick-input-list-entry.quick-input-list-separator-border { + border-top-style: none; +} +.quick-input-list .quick-input-list-label { + overflow: hidden; + display: flex; + height: 100%; + flex: 1; +} +.quick-input-list .quick-input-list-checkbox { + align-self: center; + margin: 0; +} +.quick-input-list .quick-input-list-icon { + background-size: 16px; + background-position: left center; + background-repeat: no-repeat; + padding-right: 6px; + width: 16px; + height: 22px; + display: flex; + align-items: center; + justify-content: center; +} +.quick-input-list .quick-input-list-rows { + overflow: hidden; + text-overflow: ellipsis; + display: flex; + flex-direction: column; + height: 100%; + flex: 1; + margin-left: 5px; +} +.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-rows { + margin-left: 10px; +} +.quick-input-widget .quick-input-list .quick-input-list-checkbox { + display: none; +} +.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-checkbox { + display: inline; +} +.quick-input-list .quick-input-list-rows > .quick-input-list-row { + display: flex; + align-items: center; +} +.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label, +.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label .monaco-icon-label-container > .monaco-icon-name-container { + flex: 1; +} +.quick-input-list .quick-input-list-rows > .quick-input-list-row .codicon[class*=codicon-] { + vertical-align: text-bottom; +} +.quick-input-list .quick-input-list-rows .monaco-highlighted-label > span { + opacity: 1; +} +.quick-input-list .quick-input-list-entry .quick-input-list-entry-keybinding { + margin-right: 8px; +} +.quick-input-list .quick-input-list-label-meta { + opacity: 0.7; + line-height: normal; + text-overflow: ellipsis; + overflow: hidden; +} +.quick-input-list .monaco-highlighted-label .highlight { + font-weight: bold; +} +.quick-input-list .quick-input-list-entry .quick-input-list-separator { + margin-right: 4px; +} +.quick-input-list .quick-input-list-entry-action-bar { + display: flex; + flex: 0; + overflow: visible; +} +.quick-input-list .quick-input-list-entry-action-bar .action-label { + display: none; +} +.quick-input-list .quick-input-list-entry-action-bar .action-label.codicon { + margin-right: 4px; + padding: 0px 2px 2px 2px; +} +.quick-input-list .quick-input-list-entry-action-bar { + margin-top: 1px; +} +.quick-input-list .quick-input-list-entry-action-bar { + margin-right: 4px; +} +.quick-input-list .quick-input-list-entry .quick-input-list-entry-action-bar .action-label.always-visible, +.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar .action-label, +.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar .action-label { + display: flex; +} +.quick-input-list .monaco-list-row.focused .monaco-keybinding-key, +.quick-input-list .monaco-list-row.focused .quick-input-list-entry .quick-input-list-separator { + color: inherit; +} +.quick-input-list .monaco-list-row.focused .monaco-keybinding-key { + background: none; +} +.quick-input-list .quick-input-list-separator-as-item { + font-weight: 600; + font-size: 12px; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/iconLabel/iconlabel.css */ +.monaco-icon-label { + display: flex; + overflow: hidden; + text-overflow: ellipsis; +} +.monaco-icon-label::before { + background-size: 16px; + background-position: left center; + background-repeat: no-repeat; + padding-right: 6px; + width: 16px; + height: 22px; + line-height: inherit !important; + display: inline-block; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + vertical-align: top; + flex-shrink: 0; +} +.monaco-icon-label-container.disabled { + color: var(--vscode-disabledForeground); +} +.monaco-icon-label > .monaco-icon-label-container { + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + flex: 1; +} +.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name { + color: inherit; + white-space: pre; +} +.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name > .label-separator { + margin: 0 2px; + opacity: 0.5; +} +.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + opacity: .7; + margin-left: 0.5em; + font-size: 0.9em; + white-space: pre; +} +.monaco-icon-label.nowrap > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + white-space: nowrap; +} +.vs .monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + opacity: .95; +} +.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-name-container > .label-name, +.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + font-style: italic; +} +.monaco-icon-label.deprecated { + text-decoration: line-through; + opacity: 0.66; +} +.monaco-icon-label.italic::after { + font-style: italic; +} +.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-name-container > .label-name, +.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-description-container > .label-description { + text-decoration: line-through; +} +.monaco-icon-label::after { + opacity: 0.75; + font-size: 90%; + font-weight: 600; + margin: auto 16px 0 5px; + text-align: center; +} +.monaco-list:focus .selected .monaco-icon-label, +.monaco-list:focus .selected .monaco-icon-label::after { + color: inherit !important; +} +.monaco-list-row.focused.selected .label-description, +.monaco-list-row.selected .label-description { + opacity: .8; +} + +/* node_modules/monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.css */ +.monaco-keybinding { + display: flex; + align-items: center; + line-height: 10px; +} +.monaco-keybinding > .monaco-keybinding-key { + display: inline-block; + border-style: solid; + border-width: 1px; + border-radius: 3px; + vertical-align: middle; + font-size: 11px; + padding: 3px 5px; + margin: 0 2px; +} +.monaco-keybinding > .monaco-keybinding-key:first-child { + margin-left: 0; +} +.monaco-keybinding > .monaco-keybinding-key:last-child { + margin-right: 0; +} +.monaco-keybinding > .monaco-keybinding-key-separator { + display: inline-block; +} +.monaco-keybinding > .monaco-keybinding-key-chord-separator { + width: 6px; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/style.css */ +.monaco-editor .diff-hidden-lines-widget { + width: 100%; +} +.monaco-editor .diff-hidden-lines { + height: 0px; + transform: translate(0px, -10px); + font-size: 13px; + line-height: 14px; +} +.monaco-editor .diff-hidden-lines:not(.dragging) .top:hover, +.monaco-editor .diff-hidden-lines:not(.dragging) .bottom:hover, +.monaco-editor .diff-hidden-lines .top.dragging, +.monaco-editor .diff-hidden-lines .bottom.dragging { + background-color: var(--vscode-focusBorder); +} +.monaco-editor .diff-hidden-lines .top, +.monaco-editor .diff-hidden-lines .bottom { + transition: background-color 0.1s ease-out; + height: 4px; + background-color: transparent; + background-clip: padding-box; + border-bottom: 2px solid transparent; + border-top: 4px solid transparent; + cursor: ns-resize; +} +.monaco-editor .diff-hidden-lines .top { + transform: translate(0px, 4px); +} +.monaco-editor .diff-hidden-lines .bottom { + transform: translate(0px, -6px); +} +.monaco-editor .diff-unchanged-lines { + background: var(--vscode-diffEditor-unchangedCodeBackground); +} +.monaco-editor .noModificationsOverlay { + z-index: 1; + background: var(--vscode-editor-background); + display: flex; + justify-content: center; + align-items: center; +} +.monaco-editor .diff-hidden-lines .center { + background: var(--vscode-diffEditor-unchangedRegionBackground); + color: var(--vscode-diffEditor-unchangedRegionForeground); + overflow: hidden; + display: block; + text-overflow: ellipsis; + white-space: nowrap; + height: 24px; +} +.monaco-editor .diff-hidden-lines .center span.codicon { + vertical-align: middle; +} +.monaco-editor .diff-hidden-lines .center a:hover .codicon { + cursor: pointer; + color: var(--vscode-editorLink-activeForeground) !important; +} +.monaco-editor .diff-hidden-lines div.breadcrumb-item { + cursor: pointer; +} +.monaco-editor .diff-hidden-lines div.breadcrumb-item:hover { + color: var(--vscode-editorLink-activeForeground); +} +.monaco-editor .movedOriginal { + border: 2px solid var(--vscode-diffEditor-move-border); +} +.monaco-editor .movedModified { + border: 2px solid var(--vscode-diffEditor-move-border); +} +.monaco-editor .movedOriginal.currentMove, +.monaco-editor .movedModified.currentMove { + border: 2px solid var(--vscode-diffEditor-moveActive-border); +} +.monaco-diff-editor .moved-blocks-lines path.currentMove { + stroke: var(--vscode-diffEditor-moveActive-border); +} +.monaco-diff-editor .moved-blocks-lines path { + pointer-events: visiblestroke; +} +.monaco-diff-editor .moved-blocks-lines .arrow { + fill: var(--vscode-diffEditor-move-border); +} +.monaco-diff-editor .moved-blocks-lines .arrow.currentMove { + fill: var(--vscode-diffEditor-moveActive-border); +} +.monaco-diff-editor .moved-blocks-lines .arrow-rectangle { + fill: var(--vscode-editor-background); +} +.monaco-diff-editor .moved-blocks-lines { + position: absolute; + pointer-events: none; +} +.monaco-diff-editor .moved-blocks-lines path { + fill: none; + stroke: var(--vscode-diffEditor-move-border); + stroke-width: 2; +} +.monaco-editor .char-delete.diff-range-empty { + margin-left: -1px; + border-left: solid var(--vscode-diffEditor-removedTextBackground) 3px; +} +.monaco-editor .char-insert.diff-range-empty { + border-left: solid var(--vscode-diffEditor-insertedTextBackground) 3px; +} +.monaco-editor .fold-unchanged { + cursor: pointer; +} +.monaco-diff-editor .diff-moved-code-block { + display: flex; + justify-content: flex-end; + margin-top: -4px; +} +.monaco-diff-editor .diff-moved-code-block .action-bar .action-label.codicon { + width: 12px; + height: 12px; + font-size: 12px; +} +.monaco-diff-editor .diffOverview { + z-index: 9; +} +.monaco-diff-editor .diffOverview .diffViewport { + z-index: 10; +} +.monaco-diff-editor.vs .diffOverview { + background: rgba(0, 0, 0, 0.03); +} +.monaco-diff-editor.vs-dark .diffOverview { + background: rgba(255, 255, 255, 0.01); +} +.monaco-scrollable-element.modified-in-monaco-diff-editor.vs .scrollbar { + background: rgba(0, 0, 0, 0); +} +.monaco-scrollable-element.modified-in-monaco-diff-editor.vs-dark .scrollbar { + background: rgba(0, 0, 0, 0); +} +.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-black .scrollbar { + background: none; +} +.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-light .scrollbar { + background: none; +} +.monaco-scrollable-element.modified-in-monaco-diff-editor .slider { + z-index: 10; +} +.modified-in-monaco-diff-editor .slider.active { + background: rgba(171, 171, 171, .4); +} +.modified-in-monaco-diff-editor.hc-black .slider.active { + background: none; +} +.modified-in-monaco-diff-editor.hc-light .slider.active { + background: none; +} +.monaco-editor .insert-sign, +.monaco-diff-editor .insert-sign, +.monaco-editor .delete-sign, +.monaco-diff-editor .delete-sign { + font-size: 11px !important; + opacity: 0.7 !important; + display: flex !important; + align-items: center; +} +.monaco-editor.hc-black .insert-sign, +.monaco-diff-editor.hc-black .insert-sign, +.monaco-editor.hc-black .delete-sign, +.monaco-diff-editor.hc-black .delete-sign, +.monaco-editor.hc-light .insert-sign, +.monaco-diff-editor.hc-light .insert-sign, +.monaco-editor.hc-light .delete-sign, +.monaco-diff-editor.hc-light .delete-sign { + opacity: 1; +} +.monaco-editor .inline-deleted-margin-view-zone { + text-align: right; +} +.monaco-editor .inline-added-margin-view-zone { + text-align: right; +} +.monaco-editor .arrow-revert-change { + z-index: 10; + position: absolute; +} +.monaco-editor .arrow-revert-change:hover { + cursor: pointer; +} +.monaco-editor .view-zones .view-lines .view-line span { + display: inline-block; +} +.monaco-editor .margin-view-zones .lightbulb-glyph:hover { + cursor: pointer; +} +.monaco-editor .char-insert, +.monaco-diff-editor .char-insert { + background-color: var(--vscode-diffEditor-insertedTextBackground); +} +.monaco-editor .line-insert, +.monaco-diff-editor .line-insert { + background-color: var(--vscode-diffEditor-insertedLineBackground, var(--vscode-diffEditor-insertedTextBackground)); +} +.monaco-editor .line-insert, +.monaco-editor .char-insert { + box-sizing: border-box; + border: 1px solid var(--vscode-diffEditor-insertedTextBorder); +} +.monaco-editor.hc-black .line-insert, +.monaco-editor.hc-light .line-insert, +.monaco-editor.hc-black .char-insert, +.monaco-editor.hc-light .char-insert { + border-style: dashed; +} +.monaco-editor .line-delete, +.monaco-editor .char-delete { + box-sizing: border-box; + border: 1px solid var(--vscode-diffEditor-removedTextBorder); +} +.monaco-editor.hc-black .line-delete, +.monaco-editor.hc-light .line-delete, +.monaco-editor.hc-black .char-delete, +.monaco-editor.hc-light .char-delete { + border-style: dashed; +} +.monaco-editor .inline-added-margin-view-zone, +.monaco-editor .gutter-insert, +.monaco-diff-editor .gutter-insert { + background-color: var(--vscode-diffEditorGutter-insertedLineBackground, var(--vscode-diffEditor-insertedLineBackground), var(--vscode-diffEditor-insertedTextBackground)); +} +.monaco-editor .char-delete, +.monaco-diff-editor .char-delete { + background-color: var(--vscode-diffEditor-removedTextBackground); +} +.monaco-editor .line-delete, +.monaco-diff-editor .line-delete { + background-color: var(--vscode-diffEditor-removedLineBackground, var(--vscode-diffEditor-removedTextBackground)); +} +.monaco-editor .inline-deleted-margin-view-zone, +.monaco-editor .gutter-delete, +.monaco-diff-editor .gutter-delete { + background-color: var(--vscode-diffEditorGutter-removedLineBackground, var(--vscode-diffEditor-removedLineBackground), var(--vscode-diffEditor-removedTextBackground)); +} +.monaco-diff-editor.side-by-side .editor.modified { + box-shadow: -6px 0 5px -5px var(--vscode-scrollbar-shadow); + border-left: 1px solid var(--vscode-diffEditor-border); +} +.monaco-diff-editor .diffViewport { + background: var(--vscode-scrollbarSlider-background); +} +.monaco-diff-editor .diffViewport:hover { + background: var(--vscode-scrollbarSlider-hoverBackground); +} +.monaco-diff-editor .diffViewport:active { + background: var(--vscode-scrollbarSlider-activeBackground); +} +.monaco-editor .diagonal-fill { + background-image: linear-gradient(-45deg, var(--vscode-diffEditor-diagonalFill) 12.5%, #0000 12.5%, #0000 50%, var(--vscode-diffEditor-diagonalFill) 50%, var(--vscode-diffEditor-diagonalFill) 62.5%, #0000 62.5%, #0000 100%); + background-size: 8px 8px; +} + +/* node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/accessibleDiffViewer.css */ +.monaco-diff-editor .diff-review-line-number { + text-align: right; + display: inline-block; + color: var(--vscode-editorLineNumber-foreground); +} +.monaco-diff-editor .diff-review { + position: absolute; + user-select: none; + -webkit-user-select: none; + z-index: 99; +} +.monaco-diff-editor .diff-review-summary { + padding-left: 10px; +} +.monaco-diff-editor .diff-review-shadow { + position: absolute; + box-shadow: var(--vscode-scrollbar-shadow) 0 -6px 6px -6px inset; +} +.monaco-diff-editor .diff-review-row { + white-space: pre; +} +.monaco-diff-editor .diff-review-table { + display: table; + min-width: 100%; +} +.monaco-diff-editor .diff-review-row { + display: table-row; + width: 100%; +} +.monaco-diff-editor .diff-review-spacer { + display: inline-block; + width: 10px; + vertical-align: middle; +} +.monaco-diff-editor .diff-review-spacer > .codicon { + font-size: 9px !important; +} +.monaco-diff-editor .diff-review-actions { + display: inline-block; + position: absolute; + right: 10px; + top: 2px; + z-index: 100; +} +.monaco-diff-editor .diff-review-actions .action-label { + width: 16px; + height: 16px; + margin: 2px 0; +} +/*# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/components/App/index.less", "node_modules/monaco-editor/esm/vs/editor/standalone/browser/standalone-tokens.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/aria/aria.css", "node_modules/monaco-editor/esm/vs/editor/browser/widget/media/editor.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/scrollbar/media/scrollbars.css", "node_modules/monaco-editor/esm/vs/editor/browser/controller/textAreaHandler.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lineNumbers/lineNumbers.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/margin/margin.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/mouseCursor/mouseCursor.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/decorations/decorations.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/indentGuides/indentGuides.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/lines/viewLines.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/linesDecorations/linesDecorations.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/glyphMargin/glyphMargin.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/marginDecorations/marginDecorations.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/minimap/minimap.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/rulers/rulers.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/selections/selections.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/viewCursors/viewCursors.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/blockDecorations/blockDecorations.css", "node_modules/monaco-editor/esm/vs/editor/browser/viewParts/whitespace/whitespace.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/contextview/contextview.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/list/list.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBoxCustom.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/selectBox/selectBox.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/dropdown/dropdown.css", "node_modules/monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.css", "node_modules/monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInput.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/sash/sash.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/splitview/splitview.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/table/table.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/toggle/toggle.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/findinput/findInput.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/tree/media/tree.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/button/button.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/countBadge/countBadge.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.css", "node_modules/monaco-editor/esm/vs/platform/quickinput/browser/media/quickInput.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/iconLabel/iconlabel.css", "node_modules/monaco-editor/esm/vs/base/browser/ui/keybindingLabel/keybindingLabel.css", "node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/style.css", "node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/accessibleDiffViewer.css"],
  "sourcesContent": [".app-main {\n  color: red;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n\n/* Default standalone editor fonts */\n.monaco-editor {\n\tfont-family: -apple-system, BlinkMacSystemFont, \"Segoe WPC\", \"Segoe UI\", \"HelveticaNeue-Light\", system-ui, \"Ubuntu\", \"Droid Sans\", sans-serif;\n\t--monaco-monospace-font: \"SF Mono\", Monaco, Menlo, Consolas, \"Ubuntu Mono\", \"Liberation Mono\", \"DejaVu Sans Mono\", \"Courier New\", monospace;\n}\n\n.monaco-menu .monaco-action-bar.vertical .action-item .action-menu-item:focus .action-label {\n\tstroke-width: 1.2px;\n}\n\n.monaco-editor.vs-dark .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,\n.monaco-editor.hc-black .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,\n.monaco-editor.hc-light .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label {\n\tstroke-width: 1.2px;\n}\n\n.monaco-hover p {\n\tmargin: 0;\n}\n\n/* See https://github.com/microsoft/monaco-editor/issues/2168#issuecomment-780078600 */\n.monaco-aria-container {\n\tposition: absolute !important;\n\ttop: 0; /* avoid being placed underneath a sibling element */\n\theight: 1px;\n\twidth: 1px;\n\tmargin: -1px;\n\toverflow: hidden;\n\tpadding: 0;\n\tclip: rect(1px, 1px, 1px, 1px);\n\tclip-path: inset(50%);\n}\n\n/*.monaco-editor.vs [tabindex=\"0\"]:focus {\n\toutline: 1px solid rgba(0, 122, 204, 0.4);\n\toutline-offset: -1px;\n\topacity: 1 !important;\n}\n\n.monaco-editor.vs-dark [tabindex=\"0\"]:focus {\n\toutline: 1px solid rgba(14, 99, 156, 0.6);\n\toutline-offset: -1px;\n\topacity: 1 !important;\n}*/\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-aria-container {\n\tposition: absolute; /* try to hide from window but not from screen readers */\n\tleft:-999em;\n}", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* -------------------- IE10 remove auto clear button -------------------- */\n\n::-ms-clear {\n\tdisplay: none;\n}\n\n/* All widgets */\n/* I am not a big fan of this rule */\n.monaco-editor .editor-widget input {\n\tcolor: inherit;\n}\n\n/* -------------------- Editor -------------------- */\n\n.monaco-editor {\n\tposition: relative;\n\toverflow: visible;\n\t-webkit-text-size-adjust: 100%;\n\tcolor: var(--vscode-editor-foreground);\n\tbackground-color: var(--vscode-editor-background);\n}\n.monaco-editor-background {\n\tbackground-color: var(--vscode-editor-background);\n}\n.monaco-editor .rangeHighlight {\n\tbackground-color: var(--vscode-editor-rangeHighlightBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-rangeHighlightBorder);\n}\n.monaco-editor.hc-black .rangeHighlight, .monaco-editor.hc-light .rangeHighlight {\n\tborder-style: dotted;\n}\n.monaco-editor .symbolHighlight {\n\tbackground-color: var(--vscode-editor-symbolHighlightBackground);\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-editor-symbolHighlightBorder);\n}\n.monaco-editor.hc-black .symbolHighlight, .monaco-editor.hc-light .symbolHighlight {\n\tborder-style: dotted;\n}\n\n/* -------------------- Misc -------------------- */\n\n.monaco-editor .overflow-guard {\n\tposition: relative;\n\toverflow: hidden;\n}\n\n.monaco-editor .view-overlays {\n\tposition: absolute;\n\ttop: 0;\n}\n\n/*\n.monaco-editor .auto-closed-character {\n\topacity: 0.3;\n}\n*/\n\n\n.monaco-editor .squiggly-error {\n\tborder-bottom: 4px double var(--vscode-editorError-border);\n}\n.monaco-editor .squiggly-error::before {\n\tdisplay: block;\n\tcontent: '';\n\twidth: 100%;\n\theight: 100%;\n\tbackground: var(--vscode-editorError-background);\n}\n.monaco-editor .squiggly-warning {\n\tborder-bottom: 4px double var(--vscode-editorWarning-border);\n}\n.monaco-editor .squiggly-warning::before {\n\tdisplay: block;\n\tcontent: '';\n\twidth: 100%;\n\theight: 100%;\n\tbackground: var(--vscode-editorWarning-background);\n}\n.monaco-editor .squiggly-info {\n\tborder-bottom: 4px double var(--vscode-editorInfo-border);\n}\n.monaco-editor .squiggly-info::before {\n\tdisplay: block;\n\tcontent: '';\n\twidth: 100%;\n\theight: 100%;\n\tbackground: var(--vscode-editorInfo-background);\n}\n.monaco-editor .squiggly-hint {\n\tborder-bottom: 2px dotted var(--vscode-editorHint-border);\n}\n.monaco-editor.showUnused .squiggly-unnecessary {\n\tborder-bottom: 2px dashed var(--vscode-editorUnnecessaryCode-border);\n}\n.monaco-editor.showDeprecated .squiggly-inline-deprecated {\n\ttext-decoration: line-through;\n\ttext-decoration-color: var(--vscode-editor-foreground, inherit);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Arrows */\n.monaco-scrollable-element > .scrollbar > .scra {\n\tcursor: pointer;\n\tfont-size: 11px !important;\n}\n\n.monaco-scrollable-element > .visible {\n\topacity: 1;\n\n\t/* Background rule added for IE9 - to allow clicks on dom node */\n\tbackground:rgba(0,0,0,0);\n\n\ttransition: opacity 100ms linear;\n\t/* In front of peek view */\n\tz-index: 11;\n}\n.monaco-scrollable-element > .invisible {\n\topacity: 0;\n\tpointer-events: none;\n}\n.monaco-scrollable-element > .invisible.fade {\n\ttransition: opacity 800ms linear;\n}\n\n/* Scrollable Content Inset Shadow */\n.monaco-scrollable-element > .shadow {\n\tposition: absolute;\n\tdisplay: none;\n}\n.monaco-scrollable-element > .shadow.top {\n\tdisplay: block;\n\ttop: 0;\n\tleft: 3px;\n\theight: 3px;\n\twidth: 100%;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset;\n}\n.monaco-scrollable-element > .shadow.left {\n\tdisplay: block;\n\ttop: 3px;\n\tleft: 0;\n\theight: 100%;\n\twidth: 3px;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset;\n}\n.monaco-scrollable-element > .shadow.top-left-corner {\n\tdisplay: block;\n\ttop: 0;\n\tleft: 0;\n\theight: 3px;\n\twidth: 3px;\n}\n.monaco-scrollable-element > .shadow.top.left {\n\tbox-shadow: var(--vscode-scrollbar-shadow) 6px 0 6px -6px inset;\n}\n\n.monaco-scrollable-element > .scrollbar > .slider {\n\tbackground: var(--vscode-scrollbarSlider-background);\n}\n\n.monaco-scrollable-element > .scrollbar > .slider:hover {\n\tbackground: var(--vscode-scrollbarSlider-hoverBackground);\n}\n\n.monaco-scrollable-element > .scrollbar > .slider.active {\n\tbackground: var(--vscode-scrollbarSlider-activeBackground);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .inputarea {\n\tmin-width: 0;\n\tmin-height: 0;\n\tmargin: 0;\n\tpadding: 0;\n\tposition: absolute;\n\toutline: none !important;\n\tresize: none;\n\tborder: none;\n\toverflow: hidden;\n\tcolor: transparent;\n\tbackground-color: transparent;\n\tz-index: -10;\n}\n/*.monaco-editor .inputarea {\n\tposition: fixed !important;\n\twidth: 800px !important;\n\theight: 500px !important;\n\ttop: initial !important;\n\tleft: initial !important;\n\tbottom: 0 !important;\n\tright: 0 !important;\n\tcolor: black !important;\n\tbackground: white !important;\n\tline-height: 15px !important;\n\tfont-size: 14px !important;\n\tz-index: 10 !important;\n}*/\n.monaco-editor .inputarea.ime-input {\n\tz-index: 10;\n\tcaret-color: var(--vscode-editorCursor-foreground);\n\tcolor: var(--vscode-editor-foreground);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .margin-view-overlays .line-numbers {\n\tfont-variant-numeric: tabular-nums;\n\tposition: absolute;\n\ttext-align: right;\n\tdisplay: inline-block;\n\tvertical-align: middle;\n\tbox-sizing: border-box;\n\tcursor: default;\n\theight: 100%;\n}\n\n.monaco-editor .relative-current-line-number {\n\ttext-align: left;\n\tdisplay: inline-block;\n\twidth: 100%;\n}\n\n.monaco-editor .margin-view-overlays .line-numbers.lh-odd {\n\tmargin-top: 1px;\n}\n\n.monaco-editor .line-numbers {\n\tcolor: var(--vscode-editorLineNumber-foreground);\n}\n\n.monaco-editor .line-numbers.active-line-number {\n\tcolor: var(--vscode-editorLineNumber-activeForeground);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .margin {\n\tbackground-color: var(--vscode-editorGutter-background);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-mouse-cursor-text {\n\tcursor: text;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .view-overlays .current-line {\n\tdisplay: block;\n\tposition: absolute;\n\tleft: 0;\n\ttop: 0;\n\tbox-sizing: border-box;\n}\n\n.monaco-editor .margin-view-overlays .current-line {\n\tdisplay: block;\n\tposition: absolute;\n\tleft: 0;\n\ttop: 0;\n\tbox-sizing: border-box;\n}\n\n.monaco-editor .margin-view-overlays .current-line.current-line-margin.current-line-margin-both {\n\tborder-right: 0;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/*\n\tKeeping name short for faster parsing.\n\tcdr = core decorations rendering (div)\n*/\n.monaco-editor .lines-content .cdr {\n\tposition: absolute;\n}", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .lines-content .core-guide {\n\tposition: absolute;\n\tbox-sizing: border-box;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Uncomment to see lines flashing when they're painted */\n/*.monaco-editor .view-lines > .view-line {\n\tbackground-color: none;\n\tanimation-name: flash-background;\n\tanimation-duration: 800ms;\n}\n@keyframes flash-background {\n\t0%   { background-color: lightgreen; }\n\t100% { background-color: none }\n}*/\n\n.mtkcontrol {\n\tcolor: rgb(255, 255, 255) !important;\n\tbackground: rgb(150, 0, 0) !important;\n}\n\n.mtkoverflow {\n\tbackground-color: var(--vscode-button-background, var(--vscode-editor-background));\n\tcolor: var(--vscode-button-foreground, var(--vscode-editor-foreground));\n\tborder-width: 1px;\n\tborder-style: solid;\n\tborder-color: var(--vscode-contrastBorder);\n\tborder-radius: 2px;\n\tpadding: 4px;\n\tcursor: pointer;\n}\n.mtkoverflow:hover {\n\tbackground-color: var(--vscode-button-hoverBackground);\n}\n\n.monaco-editor.no-user-select .lines-content,\n.monaco-editor.no-user-select .view-line,\n.monaco-editor.no-user-select .view-lines {\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n/* Use user-select: text for lookup feature on macOS */\n/* https://github.com/microsoft/vscode/issues/85632 */\n.monaco-editor.mac .lines-content:hover,\n.monaco-editor.mac .view-line:hover,\n.monaco-editor.mac .view-lines:hover {\n\tuser-select: text;\n\t-webkit-user-select: text;\n\t-ms-user-select: text;\n}\n\n.monaco-editor.enable-user-select {\n\tuser-select: initial;\n\t-webkit-user-select: initial;\n}\n\n.monaco-editor .view-lines {\n\twhite-space: nowrap;\n}\n\n.monaco-editor .view-line {\n\tposition: absolute;\n\twidth: 100%;\n}\n\n.monaco-editor .mtkw {\n\tcolor: var(--vscode-editorWhitespace-foreground) !important;\n}\n\n.monaco-editor .mtkz {\n\tdisplay: inline-block;\n\tcolor: var(--vscode-editorWhitespace-foreground) !important;\n}\n\n/* TODO@tokenization bootstrap fix */\n/*.monaco-editor .view-line > span > span {\n\tfloat: none;\n\tmin-height: inherit;\n\tmargin-left: inherit;\n}*/\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .lines-decorations {\n\tposition: absolute;\n\ttop: 0;\n\tbackground: white;\n}\n\n/*\n\tKeeping name short for faster parsing.\n\tcldr = core lines decorations rendering (div)\n*/\n.monaco-editor .margin-view-overlays .cldr {\n\tposition: absolute;\n\theight: 100%;\n}", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .glyph-margin {\n\tposition: absolute;\n\ttop: 0;\n}\n\n/*\n\tKeeping name short for faster parsing.\n\tcgmr = core glyph margin rendering (div)\n*/\n.monaco-editor .glyph-margin-widgets .cgmr {\n\tposition: absolute;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n/*\n\tEnsure spinning icons are pixel-perfectly centered and avoid wobble.\n\tThis is only applied to icons that spin to avoid unnecessary\n\tGPU layers and blurry subpixel AA.\n*/\n.monaco-editor .glyph-margin-widgets .cgmr.codicon-modifier-spin::before  {\n\tposition: absolute;\n\ttop: 50%;\n\tleft: 50%;\n\ttransform: translate(-50%, -50%);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/*\n\tKeeping name short for faster parsing.\n\tcmdr = core margin decorations rendering (div)\n*/\n.monaco-editor .margin-view-overlays .cmdr {\n\tposition: absolute;\n\tleft: 0;\n\twidth: 100%;\n\theight: 100%;\n}", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* START cover the case that slider is visible on mouseover */\n.monaco-editor .minimap.slider-mouseover .minimap-slider {\n\topacity: 0;\n\ttransition: opacity 100ms linear;\n}\n.monaco-editor .minimap.slider-mouseover:hover .minimap-slider {\n\topacity: 1;\n}\n.monaco-editor .minimap.slider-mouseover .minimap-slider.active {\n\topacity: 1;\n}\n/* END cover the case that slider is visible on mouseover */\n.monaco-editor .minimap-slider .minimap-slider-horizontal {\n\tbackground: var(--vscode-minimapSlider-background);\n}\n.monaco-editor .minimap-slider:hover .minimap-slider-horizontal {\n\tbackground: var(--vscode-minimapSlider-hoverBackground);\n}\n.monaco-editor .minimap-slider.active .minimap-slider-horizontal {\n\tbackground: var(--vscode-minimapSlider-activeBackground);\n}\n.monaco-editor .minimap-shadow-visible {\n\tbox-shadow: var(--vscode-scrollbar-shadow) -6px 0 6px -6px inset;\n}\n.monaco-editor .minimap-shadow-hidden {\n\tposition: absolute;\n\twidth: 0;\n}\n.monaco-editor .minimap-shadow-visible {\n\tposition: absolute;\n\tleft: -6px;\n\twidth: 6px;\n}\n.monaco-editor.no-minimap-shadow .minimap-shadow-visible {\n\tposition: absolute;\n\tleft: -1px;\n\twidth: 1px;\n}\n\n/* 0.5s fade in/out for the minimap */\n.minimap.autohide {\n\topacity: 0;\n\ttransition: opacity 0.5s;\n}\n.minimap.autohide:hover {\n\topacity: 1;\n}\n\n.monaco-editor .minimap {\n\tz-index: 5;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .overlayWidgets {\n\tposition: absolute;\n\ttop: 0;\n\tleft:0;\n}", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .view-ruler {\n\tposition: absolute;\n\ttop: 0;\n\tbox-shadow: 1px 0 0 0 var(--vscode-editorRuler-foreground) inset;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .scroll-decoration {\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\theight: 6px;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/*\n\tKeeping name short for faster parsing.\n\tcslr = core selections layer rendering (div)\n*/\n.monaco-editor .lines-content .cslr {\n\tposition: absolute;\n}\n\n.monaco-editor .focused .selected-text {\n\tbackground-color: var(--vscode-editor-selectionBackground);\n}\n\n.monaco-editor .selected-text {\n\tbackground-color: var(--vscode-editor-inactiveSelectionBackground);\n}\n\n.monaco-editor\t\t\t.top-left-radius\t\t{ border-top-left-radius: 3px; }\n.monaco-editor\t\t\t.bottom-left-radius\t\t{ border-bottom-left-radius: 3px; }\n.monaco-editor\t\t\t.top-right-radius\t\t{ border-top-right-radius: 3px; }\n.monaco-editor\t\t\t.bottom-right-radius\t{ border-bottom-right-radius: 3px; }\n\n.monaco-editor.hc-black .top-left-radius\t\t{ border-top-left-radius: 0; }\n.monaco-editor.hc-black .bottom-left-radius\t\t{ border-bottom-left-radius: 0; }\n.monaco-editor.hc-black .top-right-radius\t\t{ border-top-right-radius: 0; }\n.monaco-editor.hc-black .bottom-right-radius\t{ border-bottom-right-radius: 0; }\n\n.monaco-editor.hc-light .top-left-radius\t\t{ border-top-left-radius: 0; }\n.monaco-editor.hc-light .bottom-left-radius\t\t{ border-bottom-left-radius: 0; }\n.monaco-editor.hc-light .top-right-radius\t\t{ border-top-right-radius: 0; }\n.monaco-editor.hc-light .bottom-right-radius\t{ border-bottom-right-radius: 0; }\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n.monaco-editor .cursors-layer {\n\tposition: absolute;\n\ttop: 0;\n}\n\n.monaco-editor .cursors-layer > .cursor {\n\tposition: absolute;\n\toverflow: hidden;\n\tbox-sizing: border-box;\n}\n\n/* -- smooth-caret-animation -- */\n.monaco-editor .cursors-layer.cursor-smooth-caret-animation > .cursor {\n\ttransition: all 80ms;\n}\n\n/* -- block-outline-style -- */\n.monaco-editor .cursors-layer.cursor-block-outline-style > .cursor {\n\tbackground: transparent !important;\n\tborder-style: solid;\n\tborder-width: 1px;\n}\n\n/* -- underline-style -- */\n.monaco-editor .cursors-layer.cursor-underline-style > .cursor {\n\tborder-bottom-width: 2px;\n\tborder-bottom-style: solid;\n\tbackground: transparent !important;\n}\n\n/* -- underline-thin-style -- */\n.monaco-editor .cursors-layer.cursor-underline-thin-style > .cursor {\n\tborder-bottom-width: 1px;\n\tborder-bottom-style: solid;\n\tbackground: transparent !important;\n}\n\n@keyframes monaco-cursor-smooth {\n\t0%,\n\t20% {\n\t\topacity: 1;\n\t}\n\t60%,\n\t100% {\n\t\topacity: 0;\n\t}\n}\n\n@keyframes monaco-cursor-phase {\n\t0%,\n\t20% {\n\t\topacity: 1;\n\t}\n\t90%,\n\t100% {\n\t\topacity: 0;\n\t}\n}\n\n@keyframes monaco-cursor-expand {\n\t0%,\n\t20% {\n\t\ttransform: scaleY(1);\n\t}\n\t80%,\n\t100% {\n\t\ttransform: scaleY(0);\n\t}\n}\n\n.cursor-smooth {\n\tanimation: monaco-cursor-smooth 0.5s ease-in-out 0s 20 alternate;\n}\n\n.cursor-phase {\n\tanimation: monaco-cursor-phase 0.5s ease-in-out 0s 20 alternate;\n}\n\n.cursor-expand > .cursor {\n\tanimation: monaco-cursor-expand 0.5s ease-in-out 0s 20 alternate;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .blockDecorations-container {\n\tposition: absolute;\n\ttop: 0;\n\tpointer-events: none;\n}\n\n.monaco-editor .blockDecorations-block {\n\tposition: absolute;\n\tbox-sizing: border-box;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .mwh {\n\tposition: absolute;\n\tcolor: var(--vscode-editorWhitespace-foreground) !important;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.context-view {\n\tposition: absolute;\n}\n\n.context-view.fixed {\n\tall: initial;\n\tfont-family: inherit;\n\tfont-size: 13px;\n\tposition: fixed;\n\tcolor: inherit;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-list {\n\tposition: relative;\n\theight: 100%;\n\twidth: 100%;\n\twhite-space: nowrap;\n}\n\n.monaco-list.mouse-support {\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n.monaco-list > .monaco-scrollable-element {\n\theight: 100%;\n}\n\n.monaco-list-rows {\n\tposition: relative;\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-list.horizontal-scrolling .monaco-list-rows {\n\twidth: auto;\n\tmin-width: 100%;\n}\n\n.monaco-list-row {\n\tposition: absolute;\n\tbox-sizing: border-box;\n\toverflow: hidden;\n\twidth: 100%;\n}\n\n.monaco-list.mouse-support .monaco-list-row {\n\tcursor: pointer;\n\ttouch-action: none;\n}\n\n/* for OS X ballistic scrolling */\n.monaco-list-row.scrolling {\n\tdisplay: none !important;\n}\n\n/* Focus */\n.monaco-list.element-focused,\n.monaco-list.selection-single,\n.monaco-list.selection-multiple {\n\toutline: 0 !important;\n}\n\n/* Dnd */\n.monaco-drag-image {\n\tdisplay: inline-block;\n\tpadding: 1px 7px;\n\tborder-radius: 10px;\n\tfont-size: 12px;\n\tposition: absolute;\n\tz-index: 1000;\n}\n\n/* Filter */\n\n.monaco-list-type-filter-message {\n\tposition: absolute;\n\tbox-sizing: border-box;\n\twidth: 100%;\n\theight: 100%;\n\ttop: 0;\n\tleft: 0;\n\tpadding: 40px 1em 1em 1em;\n\ttext-align: center;\n\twhite-space: normal;\n\topacity: 0.7;\n\tpointer-events: none;\n}\n\n.monaco-list-type-filter-message:empty {\n\tdisplay: none;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* Use custom CSS vars to expose padding into parent select for padding calculation */\n.monaco-select-box-dropdown-padding {\n\t--dropdown-padding-top: 1px;\n\t--dropdown-padding-bottom: 1px;\n}\n\n.hc-black .monaco-select-box-dropdown-padding,\n.hc-light .monaco-select-box-dropdown-padding {\n\t--dropdown-padding-top: 3px;\n\t--dropdown-padding-bottom: 4px;\n}\n\n.monaco-select-box-dropdown-container {\n\tdisplay: none;\n\tbox-sizing:\tborder-box;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown * {\n\tmargin: 0;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown a:focus {\n\toutline: 1px solid -webkit-focus-ring-color;\n\toutline-offset: -1px;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane > .select-box-description-markdown code {\n\tline-height: 15px; /** For some reason, this is needed, otherwise <code> will take up 20px height */\n\tfont-family: var(--monaco-monospace-font);\n}\n\n\n.monaco-select-box-dropdown-container.visible {\n\tdisplay: flex;\n\tflex-direction: column;\n\ttext-align: left;\n\twidth: 1px;\n\toverflow: hidden;\n\tborder-bottom-left-radius: 3px;\n\tborder-bottom-right-radius: 3px;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container {\n\tflex: 0 0 auto;\n\talign-self: flex-start;\n\tpadding-top: var(--dropdown-padding-top);\n\tpadding-bottom: var(--dropdown-padding-bottom);\n\tpadding-left: 1px;\n\tpadding-right: 1px;\n\twidth: 100%;\n\toverflow: hidden;\n\tbox-sizing:\tborder-box;\n}\n\n.monaco-select-box-dropdown-container > .select-box-details-pane {\n\tpadding: 5px;\n}\n\n.hc-black .monaco-select-box-dropdown-container > .select-box-dropdown-list-container {\n\tpadding-top: var(--dropdown-padding-top);\n\tpadding-bottom: var(--dropdown-padding-bottom);\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row {\n\tcursor: pointer;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-text {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\tpadding-left: 3.5px;\n\twhite-space: nowrap;\n\tfloat: left;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-detail {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\tpadding-left: 3.5px;\n\twhite-space: nowrap;\n\tfloat: left;\n\topacity: 0.7;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .option-decorator-right {\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n\tpadding-right: 10px;\n\twhite-space: nowrap;\n\tfloat: right;\n}\n\n\n/* Accepted CSS hiding technique for accessibility reader text  */\n/* https://webaim.org/techniques/css/invisiblecontent/ */\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-list-container .monaco-list .monaco-list-row > .visually-hidden {\n\t\tposition: absolute;\n\t\tleft: -10000px;\n\t\ttop: auto;\n\t\twidth: 1px;\n\t\theight: 1px;\n\t\toverflow: hidden;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control {\n\tflex: 1 1 auto;\n\talign-self: flex-start;\n\topacity: 0;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div {\n\toverflow: hidden;\n\tmax-height: 0px;\n}\n\n.monaco-select-box-dropdown-container > .select-box-dropdown-container-width-control > .width-control-div > .option-text-width-control {\n\tpadding-left: 4px;\n\tpadding-right: 8px;\n\twhite-space: nowrap;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-select-box {\n\twidth: 100%;\n\tcursor: pointer;\n\tborder-radius: 2px;\n}\n\n.monaco-select-box-dropdown-container {\n\tfont-size: 13px;\n\tfont-weight: normal;\n\ttext-transform: none;\n}\n\n/** Actions */\n\n.monaco-action-bar .action-item.select-container {\n\tcursor: default;\n}\n\n.monaco-action-bar .action-item .monaco-select-box {\n\tcursor: pointer;\n\tmin-width: 100px;\n\tmin-height: 18px;\n\tpadding: 2px 23px 2px 8px;\n}\n\n.mac .monaco-action-bar .action-item .monaco-select-box {\n\tfont-size: 11px;\n\tborder-radius: 5px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-action-bar {\n\twhite-space: nowrap;\n\theight: 100%;\n}\n\n.monaco-action-bar .actions-container {\n\tdisplay: flex;\n\tmargin: 0 auto;\n\tpadding: 0;\n\theight: 100%;\n\twidth: 100%;\n\talign-items: center;\n}\n\n.monaco-action-bar.vertical .actions-container {\n\tdisplay: inline-block;\n}\n\n.monaco-action-bar .action-item {\n\tdisplay: block;\n\talign-items: center;\n\tjustify-content: center;\n\tcursor: pointer;\n\tposition: relative;  /* DO NOT REMOVE - this is the key to preventing the ghosting icon bug in Chrome 42 */\n}\n\n.monaco-action-bar .action-item.disabled {\n\tcursor: default;\n}\n\n.monaco-action-bar .action-item .icon,\n.monaco-action-bar .action-item .codicon {\n\tdisplay: block;\n}\n\n.monaco-action-bar .action-item .codicon {\n\tdisplay: flex;\n\talign-items: center;\n\twidth: 16px;\n\theight: 16px;\n}\n\n.monaco-action-bar .action-label {\n\tdisplay: flex;\n\tfont-size: 11px;\n\tpadding: 3px;\n\tborder-radius: 5px;\n}\n\n.monaco-action-bar .action-item.disabled .action-label,\n.monaco-action-bar .action-item.disabled .action-label::before,\n.monaco-action-bar .action-item.disabled .action-label:hover {\n\topacity: 0.6;\n}\n\n/* Vertical actions */\n\n.monaco-action-bar.vertical {\n\ttext-align: left;\n}\n\n.monaco-action-bar.vertical .action-item {\n\tdisplay: block;\n}\n\n.monaco-action-bar.vertical .action-label.separator {\n\tdisplay: block;\n\tborder-bottom: 1px solid #bbb;\n\tpadding-top: 1px;\n\tmargin-left: .8em;\n\tmargin-right: .8em;\n}\n\n.monaco-action-bar .action-item .action-label.separator {\n\twidth: 1px;\n\theight: 16px;\n\tmargin: 5px 4px !important;\n\tcursor: default;\n\tmin-width: 1px;\n\tpadding: 0;\n\tbackground-color: #bbb;\n}\n\n.secondary-actions .monaco-action-bar .action-label {\n\tmargin-left: 6px;\n}\n\n/* Action Items */\n.monaco-action-bar .action-item.select-container {\n\toverflow: hidden; /* somehow the dropdown overflows its container, we prevent it here to not push */\n\tflex: 1;\n\tmax-width: 170px;\n\tmin-width: 60px;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n\tmargin-right: 10px;\n}\n\n.monaco-action-bar .action-item.action-dropdown-item {\n\tdisplay: flex;\n}\n\n.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator {\n\tdisplay: flex;\n\talign-items: center;\n\tcursor: default;\n}\n\n.monaco-action-bar .action-item.action-dropdown-item > .action-dropdown-item-separator > div {\n\twidth: 1px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-dropdown {\n\theight: 100%;\n\tpadding: 0;\n}\n\n.monaco-dropdown > .dropdown-label {\n\tcursor: pointer;\n\theight: 100%;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n.monaco-dropdown > .dropdown-label > .action-label.disabled {\n\tcursor: default;\n}\n\n.monaco-dropdown-with-primary {\n\tdisplay: flex !important;\n\tflex-direction: row;\n\tborder-radius: 5px;\n}\n\n.monaco-dropdown-with-primary > .action-container > .action-label {\n\tmargin-right: 0;\n}\n\n.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*='codicon-'] {\n\tfont-size: 12px;\n\tpadding-left: 0px;\n\tpadding-right: 0px;\n\tline-height: 16px;\n\tmargin-left: -3px;\n}\n\n.monaco-dropdown-with-primary > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label {\n\tdisplay: block;\n\tbackground-size: 16px;\n\tbackground-position: center center;\n\tbackground-repeat: no-repeat;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-action-bar .action-item.menu-entry .action-label.icon {\n\twidth: 16px;\n\theight: 16px;\n\tbackground-repeat: no-repeat;\n\tbackground-position: 50%;\n\tbackground-size: 16px;\n}\n\n.monaco-dropdown-with-default {\n\tdisplay: flex !important;\n\tflex-direction: row;\n\tborder-radius: 5px;\n}\n\n.monaco-dropdown-with-default > .action-container > .action-label {\n\tmargin-right: 0;\n}\n\n.monaco-dropdown-with-default > .action-container.menu-entry > .action-label.icon {\n\twidth: 16px;\n\theight: 16px;\n\tbackground-repeat: no-repeat;\n\tbackground-position: 50%;\n\tbackground-size: 16px;\n}\n\n.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label .codicon[class*='codicon-'] {\n\tfont-size: 12px;\n\tpadding-left: 0px;\n\tpadding-right: 0px;\n\tline-height: 16px;\n\tmargin-left: -3px;\n}\n\n.monaco-dropdown-with-default > .dropdown-action-container > .monaco-dropdown > .dropdown-label > .action-label {\n\tdisplay: block;\n\tbackground-size: 16px;\n\tbackground-position: center center;\n\tbackground-repeat: no-repeat;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.quick-input-widget {\n\tfont-size: 13px;\n}\n\n.quick-input-widget .monaco-highlighted-label .highlight,\n.quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #0066BF;\n}\n\n.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight,\n.vs .quick-input-widget .monaco-list-row.focused .monaco-highlighted-label .highlight {\n\tcolor: #9DDDFF;\n}\n\n.vs-dark .quick-input-widget .monaco-highlighted-label .highlight,\n.vs-dark .quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #0097fb;\n}\n\n.hc-black .quick-input-widget .monaco-highlighted-label .highlight,\n.hc-black .quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #F38518;\n}\n\n.hc-light .quick-input-widget .monaco-highlighted-label .highlight,\n.hc-light .quick-input-widget .monaco-highlighted-label .highlight {\n\tcolor: #0F4A85;\n}\n\n.monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: rgba(221, 221, 221, 0.4);\n\tborder: solid 1px rgba(204, 204, 204, 0.4);\n\tborder-bottom-color: rgba(187, 187, 187, 0.4);\n\tbox-shadow: inset 0 -1px 0 rgba(187, 187, 187, 0.4);\n\tcolor: #555;\n}\n\n.hc-black .monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: transparent;\n\tborder: solid 1px rgb(111, 195, 223);\n\tbox-shadow: none;\n\tcolor: #fff;\n}\n\n.hc-light .monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: transparent;\n\tborder: solid 1px #0F4A85;\n\tbox-shadow: none;\n\tcolor: #292929;\n}\n\n.vs-dark .monaco-keybinding > .monaco-keybinding-key {\n\tbackground-color: rgba(128, 128, 128, 0.17);\n\tborder: solid 1px rgba(51, 51, 51, 0.6);\n\tborder-bottom-color: rgba(68, 68, 68, 0.6);\n\tbox-shadow: inset 0 -1px 0 rgba(68, 68, 68, 0.6);\n\tcolor: #ccc;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n:root {\n\t--vscode-sash-size: 4px;\n\t--vscode-sash-hover-size: 4px;\n}\n\n.monaco-sash {\n\tposition: absolute;\n\tz-index: 35;\n\ttouch-action: none;\n}\n\n.monaco-sash.disabled {\n\tpointer-events: none;\n}\n\n.monaco-sash.mac.vertical {\n\tcursor: col-resize;\n}\n\n.monaco-sash.vertical.minimum {\n\tcursor: e-resize;\n}\n\n.monaco-sash.vertical.maximum {\n\tcursor: w-resize;\n}\n\n.monaco-sash.mac.horizontal {\n\tcursor: row-resize;\n}\n\n.monaco-sash.horizontal.minimum {\n\tcursor: s-resize;\n}\n\n.monaco-sash.horizontal.maximum {\n\tcursor: n-resize;\n}\n\n.monaco-sash.disabled {\n\tcursor: default !important;\n\tpointer-events: none !important;\n}\n\n.monaco-sash.vertical {\n\tcursor: ew-resize;\n\ttop: 0;\n\twidth: var(--vscode-sash-size);\n\theight: 100%;\n}\n\n.monaco-sash.horizontal {\n\tcursor: ns-resize;\n\tleft: 0;\n\twidth: 100%;\n\theight: var(--vscode-sash-size);\n}\n\n.monaco-sash:not(.disabled) > .orthogonal-drag-handle {\n\tcontent: \" \";\n\theight: calc(var(--vscode-sash-size) * 2);\n\twidth: calc(var(--vscode-sash-size) * 2);\n\tz-index: 100;\n\tdisplay: block;\n\tcursor: all-scroll;\n\tposition: absolute;\n}\n\n.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled)\n\t> .orthogonal-drag-handle.start,\n.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled)\n\t> .orthogonal-drag-handle.end {\n\tcursor: nwse-resize;\n}\n\n.monaco-sash.horizontal.orthogonal-edge-north:not(.disabled)\n\t> .orthogonal-drag-handle.end,\n.monaco-sash.horizontal.orthogonal-edge-south:not(.disabled)\n\t> .orthogonal-drag-handle.start {\n\tcursor: nesw-resize;\n}\n\n.monaco-sash.vertical > .orthogonal-drag-handle.start {\n\tleft: calc(var(--vscode-sash-size) * -0.5);\n\ttop: calc(var(--vscode-sash-size) * -1);\n}\n.monaco-sash.vertical > .orthogonal-drag-handle.end {\n\tleft: calc(var(--vscode-sash-size) * -0.5);\n\tbottom: calc(var(--vscode-sash-size) * -1);\n}\n.monaco-sash.horizontal > .orthogonal-drag-handle.start {\n\ttop: calc(var(--vscode-sash-size) * -0.5);\n\tleft: calc(var(--vscode-sash-size) * -1);\n}\n.monaco-sash.horizontal > .orthogonal-drag-handle.end {\n\ttop: calc(var(--vscode-sash-size) * -0.5);\n\tright: calc(var(--vscode-sash-size) * -1);\n}\n\n.monaco-sash:before {\n\tcontent: '';\n\tpointer-events: none;\n\tposition: absolute;\n\twidth: 100%;\n\theight: 100%;\n\tbackground: transparent;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-sash:before {\n\ttransition: background-color 0.1s ease-out;\n}\n\n.monaco-sash.hover:before,\n.monaco-sash.active:before {\n\tbackground: var(--vscode-sash-hoverBorder);\n}\n\n.monaco-sash.vertical:before {\n\twidth: var(--vscode-sash-hover-size);\n\tleft: calc(50% - (var(--vscode-sash-hover-size) / 2));\n}\n\n.monaco-sash.horizontal:before {\n\theight: var(--vscode-sash-hover-size);\n\ttop: calc(50% - (var(--vscode-sash-hover-size) / 2));\n}\n\n.pointer-events-disabled {\n\tpointer-events: none !important;\n}\n\n/** Debug **/\n\n.monaco-sash.debug {\n\tbackground: cyan;\n}\n\n.monaco-sash.debug.disabled {\n\tbackground: rgba(0, 255, 255, 0.2);\n}\n\n.monaco-sash.debug:not(.disabled) > .orthogonal-drag-handle {\n\tbackground: red;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-split-view2 {\n\tposition: relative;\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-split-view2 > .sash-container {\n\tposition: absolute;\n\twidth: 100%;\n\theight: 100%;\n\tpointer-events: none;\n}\n\n.monaco-split-view2 > .sash-container > .monaco-sash {\n\tpointer-events: initial;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element {\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element > .split-view-container {\n\twidth: 100%;\n\theight: 100%;\n\twhite-space: nowrap;\n\tposition: relative;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view {\n\twhite-space: initial;\n\tposition: absolute;\n}\n\n.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view:not(.visible) {\n\tdisplay: none;\n}\n\n.monaco-split-view2.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view {\n\twidth: 100%;\n}\n\n.monaco-split-view2.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view {\n\theight: 100%;\n}\n\n.monaco-split-view2.separator-border > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before {\n\tcontent: ' ';\n\tposition: absolute;\n\ttop: 0;\n\tleft: 0;\n\tz-index: 5;\n\tpointer-events: none;\n\tbackground-color: var(--separator-border);\n}\n\n.monaco-split-view2.separator-border.horizontal > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before {\n\theight: 100%;\n\twidth: 1px;\n}\n\n.monaco-split-view2.separator-border.vertical > .monaco-scrollable-element > .split-view-container > .split-view-view:not(:first-child)::before {\n\theight: 1px;\n\twidth: 100%;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-table {\n\tdisplay: flex;\n\tflex-direction: column;\n\tposition: relative;\n\theight: 100%;\n\twidth: 100%;\n\twhite-space: nowrap;\n\toverflow: hidden;\n}\n\n.monaco-table > .monaco-split-view2 {\n\tborder-bottom: 1px solid transparent;\n}\n\n.monaco-table > .monaco-list {\n\tflex: 1;\n}\n\n.monaco-table-tr {\n\tdisplay: flex;\n\theight: 100%;\n}\n\n.monaco-table-th {\n\twidth: 100%;\n\theight: 100%;\n\tfont-weight: bold;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-table-th,\n.monaco-table-td {\n\tbox-sizing: border-box;\n\tflex-shrink: 0;\n\toverflow: hidden;\n\twhite-space: nowrap;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-table > .monaco-split-view2 .monaco-sash.vertical::before {\n\tcontent: \"\";\n\tposition: absolute;\n\tleft: calc(var(--vscode-sash-size) / 2);\n\twidth: 0;\n\tborder-left: 1px solid transparent;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2,\n.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2 .monaco-sash.vertical::before {\n\ttransition: border-color 0.2s ease-out;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-custom-toggle {\n\tmargin-left: 2px;\n\tfloat: left;\n\tcursor: pointer;\n\toverflow: hidden;\n\twidth: 20px;\n\theight: 20px;\n\tborder-radius: 3px;\n\tborder: 1px solid transparent;\n\tpadding: 1px;\n\tbox-sizing:\tborder-box;\n\tuser-select: none;\n\t-webkit-user-select: none;\n}\n\n.monaco-custom-toggle:hover {\n\tbackground-color: var(--vscode-inputOption-hoverBackground);\n}\n\n.hc-black .monaco-custom-toggle:hover,\n.hc-light .monaco-custom-toggle:hover {\n\tborder: 1px dashed var(--vscode-focusBorder);\n}\n\n.hc-black .monaco-custom-toggle,\n.hc-light .monaco-custom-toggle {\n\tbackground: none;\n}\n\n.hc-black .monaco-custom-toggle:hover,\n.hc-light .monaco-custom-toggle:hover {\n\tbackground: none;\n}\n\n.monaco-custom-toggle.monaco-checkbox {\n\theight: 18px;\n\twidth: 18px;\n\tborder: 1px solid transparent;\n\tborder-radius: 3px;\n\tmargin-right: 9px;\n\tmargin-left: 0px;\n\tpadding: 0px;\n\topacity: 1;\n\tbackground-size: 16px !important;\n}\n\n/* hide check when unchecked */\n.monaco-custom-toggle.monaco-checkbox:not(.checked)::before {\n\tvisibility: hidden;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-inputbox {\n\tposition: relative;\n\tdisplay: block;\n\tpadding: 0;\n\tbox-sizing:\tborder-box;\n\tborder-radius: 2px;\n\n\t/* Customizable */\n\tfont-size: inherit;\n}\n\n.monaco-inputbox > .ibwrapper > .input,\n.monaco-inputbox > .ibwrapper > .mirror {\n\n\t/* Customizable */\n\tpadding: 4px 6px;\n}\n\n.monaco-inputbox > .ibwrapper {\n\tposition: relative;\n\twidth: 100%;\n\theight: 100%;\n}\n\n.monaco-inputbox > .ibwrapper > .input {\n\tdisplay: inline-block;\n\tbox-sizing:\tborder-box;\n\twidth: 100%;\n\theight: 100%;\n\tline-height: inherit;\n\tborder: none;\n\tfont-family: inherit;\n\tfont-size: inherit;\n\tresize: none;\n\tcolor: inherit;\n}\n\n.monaco-inputbox > .ibwrapper > input {\n\ttext-overflow: ellipsis;\n}\n\n.monaco-inputbox > .ibwrapper > textarea.input {\n\tdisplay: block;\n\tscrollbar-width: none; /* Firefox: hide scrollbars */\n\toutline: none;\n}\n\n.monaco-inputbox > .ibwrapper > textarea.input::-webkit-scrollbar {\n\tdisplay: none; /* Chrome + Safari: hide scrollbar */\n}\n\n.monaco-inputbox > .ibwrapper > textarea.input.empty {\n\twhite-space: nowrap;\n}\n\n.monaco-inputbox > .ibwrapper > .mirror {\n\tposition: absolute;\n\tdisplay: inline-block;\n\twidth: 100%;\n\ttop: 0;\n\tleft: 0;\n\tbox-sizing: border-box;\n\twhite-space: pre-wrap;\n\tvisibility: hidden;\n\tword-wrap: break-word;\n}\n\n/* Context view */\n\n.monaco-inputbox-container {\n\ttext-align: right;\n}\n\n.monaco-inputbox-container .monaco-inputbox-message {\n\tdisplay: inline-block;\n\toverflow: hidden;\n\ttext-align: left;\n\twidth: 100%;\n\tbox-sizing:\tborder-box;\n\tpadding: 0.4em;\n\tfont-size: 12px;\n\tline-height: 17px;\n\tmargin-top: -1px;\n\tword-wrap: break-word;\n}\n\n/* Action bar support */\n.monaco-inputbox .monaco-action-bar {\n\tposition: absolute;\n\tright: 2px;\n\ttop: 4px;\n}\n\n.monaco-inputbox .monaco-action-bar .action-item {\n\tmargin-left: 2px;\n}\n\n.monaco-inputbox .monaco-action-bar .action-item .codicon {\n\tbackground-repeat: no-repeat;\n\twidth: 16px;\n\theight: 16px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/* ---------- Find input ---------- */\n\n.monaco-findInput {\n\tposition: relative;\n}\n\n.monaco-findInput .monaco-inputbox {\n\tfont-size: 13px;\n\twidth: 100%;\n}\n\n.monaco-findInput > .controls {\n\tposition: absolute;\n\ttop: 3px;\n\tright: 2px;\n}\n\n.vs .monaco-findInput.disabled {\n\tbackground-color: #E1E1E1;\n}\n\n/* Theming */\n.vs-dark .monaco-findInput.disabled {\n\tbackground-color: #333;\n}\n\n/* Highlighting */\n.monaco-findInput.highlight-0 .controls,\n.hc-light .monaco-findInput.highlight-0 .controls {\n\tanimation: monaco-findInput-highlight-0 100ms linear 0s;\n}\n\n.monaco-findInput.highlight-1 .controls,\n.hc-light .monaco-findInput.highlight-1 .controls {\n\tanimation: monaco-findInput-highlight-1 100ms linear 0s;\n}\n\n.hc-black .monaco-findInput.highlight-0 .controls,\n.vs-dark  .monaco-findInput.highlight-0 .controls {\n\tanimation: monaco-findInput-highlight-dark-0 100ms linear 0s;\n}\n\n.hc-black .monaco-findInput.highlight-1 .controls,\n.vs-dark  .monaco-findInput.highlight-1 .controls {\n\tanimation: monaco-findInput-highlight-dark-1 100ms linear 0s;\n}\n\n@keyframes monaco-findInput-highlight-0 {\n\t0% { background: rgba(253, 255, 0, 0.8); }\n\t100% { background: transparent; }\n}\n@keyframes monaco-findInput-highlight-1 {\n\t0% { background: rgba(253, 255, 0, 0.8); }\n\t/* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/\n\t99% { background: transparent; }\n}\n\n@keyframes monaco-findInput-highlight-dark-0 {\n\t0% { background: rgba(255, 255, 255, 0.44); }\n\t100% { background: transparent; }\n}\n@keyframes monaco-findInput-highlight-dark-1 {\n\t0% { background: rgba(255, 255, 255, 0.44); }\n\t/* Made intentionally different such that the CSS minifier does not collapse the two animations into a single one*/\n\t99% { background: transparent; }\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-tl-row {\n\tdisplay: flex;\n\theight: 100%;\n\talign-items: center;\n\tposition: relative;\n}\n\n.monaco-tl-row.disabled {\n\tcursor: default;\n}\n.monaco-tl-indent {\n\theight: 100%;\n\tposition: absolute;\n\ttop: 0;\n\tleft: 16px;\n\tpointer-events: none;\n}\n\n.hide-arrows .monaco-tl-indent {\n\tleft: 12px;\n}\n\n.monaco-tl-indent > .indent-guide {\n\tdisplay: inline-block;\n\tbox-sizing: border-box;\n\theight: 100%;\n\tborder-left: 1px solid transparent;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-tl-indent > .indent-guide {\n\ttransition: border-color 0.1s linear;\n}\n\n.monaco-tl-twistie,\n.monaco-tl-contents {\n\theight: 100%;\n}\n\n.monaco-tl-twistie {\n\tfont-size: 10px;\n\ttext-align: right;\n\tpadding-right: 6px;\n\tflex-shrink: 0;\n\twidth: 16px;\n\tdisplay: flex !important;\n\talign-items: center;\n\tjustify-content: center;\n\ttransform: translateX(3px);\n}\n\n.monaco-tl-contents {\n\tflex: 1;\n\toverflow: hidden;\n}\n\n.monaco-tl-twistie::before {\n\tborder-radius: 20px;\n}\n\n.monaco-tl-twistie.collapsed::before {\n\ttransform: rotate(-90deg);\n}\n\n.monaco-tl-twistie.codicon-tree-item-loading::before {\n\t/* Use steps to throttle FPS to reduce CPU usage */\n\tanimation: codicon-spin 1.25s steps(30) infinite;\n}\n\n.monaco-tree-type-filter {\n\tposition: absolute;\n\ttop: 0;\n\tdisplay: flex;\n\tpadding: 3px;\n\tmax-width: 200px;\n\tz-index: 100;\n\tmargin: 0 6px;\n\tborder: 1px solid var(--vscode-widget-border);\n\tborder-bottom-left-radius: 4px;\n\tborder-bottom-right-radius: 4px;\n}\n\n.monaco-workbench:not(.reduce-motion) .monaco-tree-type-filter {\n\ttransition: top 0.3s;\n}\n\n.monaco-tree-type-filter.disabled {\n\ttop: -40px !important;\n}\n\n.monaco-tree-type-filter-grab {\n\tdisplay: flex !important;\n\talign-items: center;\n\tjustify-content: center;\n\tcursor: grab;\n\tmargin-right: 2px;\n}\n\n.monaco-tree-type-filter-grab.grabbing {\n\tcursor: grabbing;\n}\n\n.monaco-tree-type-filter-input {\n\tflex: 1;\n}\n\n.monaco-tree-type-filter-input .monaco-inputbox {\n\theight: 23px;\n}\n\n.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .input,\n.monaco-tree-type-filter-input .monaco-inputbox > .ibwrapper > .mirror {\n\tpadding: 2px 4px;\n}\n\n.monaco-tree-type-filter-input .monaco-findInput > .controls {\n\ttop: 2px;\n}\n\n.monaco-tree-type-filter-actionbar {\n\tmargin-left: 4px;\n}\n\n.monaco-tree-type-filter-actionbar .monaco-action-bar .action-label {\n\tpadding: 2px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-text-button {\n\tbox-sizing: border-box;\n\tdisplay: flex;\n\twidth: 100%;\n\tpadding: 4px;\n\tborder-radius: 2px;\n\ttext-align: center;\n\tcursor: pointer;\n\tjustify-content: center;\n\talign-items: center;\n\tborder: 1px solid var(--vscode-button-border, transparent);\n\tline-height: 18px;\n}\n\n.monaco-text-button:focus {\n\toutline-offset: 2px !important;\n}\n\n.monaco-text-button:hover {\n\ttext-decoration: none !important;\n}\n\n.monaco-button.disabled:focus,\n.monaco-button.disabled {\n\topacity: 0.4 !important;\n\tcursor: default;\n}\n\n.monaco-text-button .codicon {\n\tmargin: 0 0.2em;\n\tcolor: inherit !important;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label {\n\tflex-direction: row;\n\tflex-wrap: wrap;\n\tpadding: 0 4px;\n\toverflow: hidden;\n\theight: 28px;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label {\n\tflex-basis: 100%;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short {\n\tflex-grow: 1;\n\twidth: 0;\n\toverflow: hidden;\n}\n\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label,\n.monaco-text-button.monaco-text-button-with-short-label > .monaco-button-label-short {\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n\tfont-weight: normal;\n\tfont-style: inherit;\n\tpadding: 4px 0;\n}\n\n.monaco-button-dropdown {\n\tdisplay: flex;\n\tcursor: pointer;\n}\n\n.monaco-button-dropdown.disabled {\n\tcursor: default;\n}\n\n.monaco-button-dropdown > .monaco-button:focus {\n\toutline-offset: -1px !important;\n}\n\n.monaco-button-dropdown.disabled > .monaco-button.disabled,\n.monaco-button-dropdown.disabled > .monaco-button.disabled:focus,\n.monaco-button-dropdown.disabled > .monaco-button-dropdown-separator {\n\topacity: 0.4 !important;\n}\n\n.monaco-button-dropdown > .monaco-button.monaco-text-button {\n\tborder-right-width: 0 !important;\n}\n\n.monaco-button-dropdown .monaco-button-dropdown-separator {\n\tpadding: 4px 0;\n\tcursor: default;\n}\n\n.monaco-button-dropdown .monaco-button-dropdown-separator > div {\n\theight: 100%;\n\twidth: 1px;\n}\n\n.monaco-button-dropdown > .monaco-button.monaco-dropdown-button {\n\tborder: 1px solid var(--vscode-button-border, transparent);\n\tborder-left-width: 0 !important;\n\tborder-radius: 0 2px 2px 0;\n}\n\n.monaco-button-dropdown > .monaco-button.monaco-text-button {\n\tborder-radius: 2px 0 0 2px;\n}\n\n.monaco-description-button {\n\tdisplay: flex;\n\tflex-direction: column;\n\talign-items: center;\n\tmargin: 4px 5px; /* allows button focus outline to be visible */\n}\n\n.monaco-description-button .monaco-button-description {\n\tfont-style: italic;\n\tfont-size: 11px;\n\tpadding: 4px 20px;\n}\n\n.monaco-description-button .monaco-button-label,\n.monaco-description-button .monaco-button-description {\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n}\n\n.monaco-description-button .monaco-button-label > .codicon,\n.monaco-description-button .monaco-button-description > .codicon {\n\tmargin: 0 0.2em;\n\tcolor: inherit !important;\n}\n\n/* default color styles - based on CSS variables */\n\n.monaco-button.default-colors,\n.monaco-button-dropdown.default-colors > .monaco-button{\n\tcolor: var(--vscode-button-foreground);\n\tbackground-color: var(--vscode-button-background);\n}\n\n.monaco-button.default-colors:hover,\n.monaco-button-dropdown.default-colors > .monaco-button:hover {\n\tbackground-color: var(--vscode-button-hoverBackground);\n}\n\n.monaco-button.default-colors.secondary,\n.monaco-button-dropdown.default-colors > .monaco-button.secondary {\n\tcolor: var(--vscode-button-secondaryForeground);\n\tbackground-color: var(--vscode-button-secondaryBackground);\n}\n\n.monaco-button.default-colors.secondary:hover,\n.monaco-button-dropdown.default-colors > .monaco-button.secondary:hover {\n\tbackground-color: var(--vscode-button-secondaryHoverBackground);\n}\n\n.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator {\n\tbackground-color: var(--vscode-button-background);\n\tborder-top: 1px solid var(--vscode-button-border);\n\tborder-bottom: 1px solid var(--vscode-button-border);\n}\n\n.monaco-button-dropdown.default-colors .monaco-button.secondary + .monaco-button-dropdown-separator {\n\tbackground-color: var(--vscode-button-secondaryBackground);\n}\n\n.monaco-button-dropdown.default-colors .monaco-button-dropdown-separator > div {\n\tbackground-color: var(--vscode-button-separator);\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-count-badge {\n\tpadding: 3px 6px;\n\tborder-radius: 11px;\n\tfont-size: 11px;\n\tmin-width: 18px;\n\tmin-height: 18px;\n\tline-height: 11px;\n\tfont-weight: normal;\n\ttext-align: center;\n\tdisplay: inline-block;\n\tbox-sizing: border-box;\n}\n\n.monaco-count-badge.long {\n\tpadding: 2px 3px;\n\tborder-radius: 2px;\n\tmin-height: auto;\n\tline-height: normal;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-progress-container {\n\twidth: 100%;\n\theight: 5px;\n\toverflow: hidden; /* keep progress bit in bounds */\n}\n\n.monaco-progress-container .progress-bit {\n\twidth: 2%;\n\theight: 5px;\n\tposition: absolute;\n\tleft: 0;\n\tdisplay: none;\n}\n\n.monaco-progress-container.active .progress-bit {\n\tdisplay: inherit;\n}\n\n.monaco-progress-container.discrete .progress-bit {\n\tleft: 0;\n\ttransition: width 100ms linear;\n}\n\n.monaco-progress-container.discrete.done .progress-bit {\n\twidth: 100%;\n}\n\n.monaco-progress-container.infinite .progress-bit {\n\tanimation-name: progress;\n\tanimation-duration: 4s;\n\tanimation-iteration-count: infinite;\n\ttransform: translate3d(0px, 0px, 0px);\n\tanimation-timing-function: linear;\n}\n\n.monaco-progress-container.infinite.infinite-long-running .progress-bit {\n\t/*\n\t\tThe more smooth `linear` timing function can cause\n\t\thigher GPU consumption as indicated in\n\t\thttps://github.com/microsoft/vscode/issues/97900 &\n\t\thttps://github.com/microsoft/vscode/issues/138396\n\t*/\n\tanimation-timing-function: steps(100);\n}\n\n/**\n * The progress bit has a width: 2% (1/50) of the parent container. The animation moves it from 0% to 100% of\n * that container. Since translateX is relative to the progress bit size, we have to multiple it with\n * its relative size to the parent container:\n * parent width: 5000%\n *    bit width: 100%\n * translateX should be as follow:\n *  50%: 5000% * 50% - 50% (set to center) = 2450%\n * 100%: 5000% * 100% - 100% (do not overflow) = 4900%\n */\n@keyframes progress { from { transform: translateX(0%) scaleX(1) } 50% { transform: translateX(2500%) scaleX(3) } to { transform: translateX(4900%) scaleX(1) } }\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.quick-input-widget {\n\tposition: absolute;\n\twidth: 600px;\n\tz-index: 2550;\n\tleft: 50%;\n\tmargin-left: -300px;\n\t-webkit-app-region: no-drag;\n\tborder-radius: 6px;\n}\n\n.quick-input-titlebar {\n\tdisplay: flex;\n\talign-items: center;\n\tborder-top-left-radius: 5px; /* match border radius of quick input widget */\n\tborder-top-right-radius: 5px;\n}\n\n.quick-input-left-action-bar {\n\tdisplay: flex;\n\tmargin-left: 4px;\n\tflex: 1;\n}\n\n.quick-input-title {\n\tpadding: 3px 0px;\n\ttext-align: center;\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n}\n\n.quick-input-right-action-bar {\n\tdisplay: flex;\n\tmargin-right: 4px;\n\tflex: 1;\n}\n\n.quick-input-right-action-bar > .actions-container {\n\tjustify-content: flex-end;\n}\n\n.quick-input-titlebar .monaco-action-bar .action-label.codicon {\n\tbackground-position: center;\n\tbackground-repeat: no-repeat;\n\tpadding: 2px;\n}\n\n.quick-input-description {\n\tmargin: 6px 6px 6px 11px;\n}\n\n.quick-input-header .quick-input-description {\n\tmargin: 4px 2px;\n\tflex: 1;\n}\n\n.quick-input-header {\n\tdisplay: flex;\n\tpadding: 8px 6px 6px 6px;\n}\n\n.quick-input-widget.hidden-input .quick-input-header {\n\t/* reduce margins and paddings when input box hidden */\n\tpadding: 0;\n\tmargin-bottom: 0;\n}\n\n.quick-input-and-message {\n\tdisplay: flex;\n\tflex-direction: column;\n\tflex-grow: 1;\n\tmin-width: 0;\n\tposition: relative;\n}\n\n.quick-input-check-all {\n\talign-self: center;\n\tmargin: 0;\n}\n\n.quick-input-filter {\n\tflex-grow: 1;\n\tdisplay: flex;\n\tposition: relative;\n}\n\n.quick-input-box {\n\tflex-grow: 1;\n}\n\n.quick-input-widget.show-checkboxes .quick-input-box,\n.quick-input-widget.show-checkboxes .quick-input-message {\n\tmargin-left: 5px;\n}\n\n.quick-input-visible-count {\n\tposition: absolute;\n\tleft: -10000px;\n}\n\n.quick-input-count {\n\talign-self: center;\n\tposition: absolute;\n\tright: 4px;\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.quick-input-count .monaco-count-badge {\n\tvertical-align: middle;\n\tpadding: 2px 4px;\n\tborder-radius: 2px;\n\tmin-height: auto;\n\tline-height: normal;\n}\n\n.quick-input-action {\n\tmargin-left: 6px;\n}\n\n.quick-input-action .monaco-text-button {\n\tfont-size: 11px;\n\tpadding: 0 6px;\n\tdisplay: flex;\n\theight: 25px;\n\talign-items: center;\n}\n\n.quick-input-message {\n\tmargin-top: -1px;\n\tpadding: 5px;\n\toverflow-wrap: break-word;\n}\n\n.quick-input-message > .codicon {\n\tmargin: 0 0.2em;\n\tvertical-align: text-bottom;\n}\n\n/* Links in descriptions & validations */\n.quick-input-message a {\n\tcolor: inherit;\n}\n\n.quick-input-progress.monaco-progress-container {\n\tposition: relative;\n}\n\n.quick-input-progress.monaco-progress-container,\n.quick-input-progress.monaco-progress-container .progress-bit {\n\theight: 2px;\n}\n\n.quick-input-list {\n\tline-height: 22px;\n}\n\n.quick-input-widget.hidden-input .quick-input-list {\n\tmargin-top: 4px; /* reduce margins when input box hidden */\n\tpadding-bottom: 4px;\n}\n\n.quick-input-list .monaco-list {\n\toverflow: hidden;\n\tmax-height: calc(20 * 22px);\n\tpadding-bottom: 5px;\n}\n\n.quick-input-list .monaco-scrollable-element {\n\tpadding: 0px 5px;\n}\n\n.quick-input-list .quick-input-list-entry {\n\tbox-sizing: border-box;\n\toverflow: hidden;\n\tdisplay: flex;\n\theight: 100%;\n\tpadding: 0 6px;\n}\n\n.quick-input-list .quick-input-list-entry.quick-input-list-separator-border {\n\tborder-top-width: 1px;\n\tborder-top-style: solid;\n}\n\n.quick-input-list .monaco-list-row {\n\tborder-radius: 3px;\n}\n\n.quick-input-list .monaco-list-row[data-index=\"0\"] .quick-input-list-entry.quick-input-list-separator-border {\n\tborder-top-style: none;\n}\n\n.quick-input-list .quick-input-list-label {\n\toverflow: hidden;\n\tdisplay: flex;\n\theight: 100%;\n\tflex: 1;\n}\n\n.quick-input-list .quick-input-list-checkbox {\n\talign-self: center;\n\tmargin: 0;\n}\n\n.quick-input-list .quick-input-list-icon {\n\tbackground-size: 16px;\n\tbackground-position: left center;\n\tbackground-repeat: no-repeat;\n\tpadding-right: 6px;\n\twidth: 16px;\n\theight: 22px;\n\tdisplay: flex;\n\talign-items: center;\n\tjustify-content: center;\n}\n\n.quick-input-list .quick-input-list-rows {\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tdisplay: flex;\n\tflex-direction: column;\n\theight: 100%;\n\tflex: 1;\n\tmargin-left: 5px;\n}\n\n.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-rows {\n\tmargin-left: 10px;\n}\n\n.quick-input-widget .quick-input-list .quick-input-list-checkbox {\n\tdisplay: none;\n}\n.quick-input-widget.show-checkboxes .quick-input-list .quick-input-list-checkbox {\n\tdisplay: inline;\n}\n\n.quick-input-list .quick-input-list-rows > .quick-input-list-row {\n\tdisplay: flex;\n\talign-items: center;\n}\n\n.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label,\n.quick-input-list .quick-input-list-rows > .quick-input-list-row .monaco-icon-label .monaco-icon-label-container > .monaco-icon-name-container {\n\tflex: 1; /* make sure the icon label grows within the row */\n}\n\n.quick-input-list .quick-input-list-rows > .quick-input-list-row .codicon[class*='codicon-'] {\n\tvertical-align: text-bottom;\n}\n\n.quick-input-list .quick-input-list-rows .monaco-highlighted-label > span {\n\topacity: 1;\n}\n\n.quick-input-list .quick-input-list-entry .quick-input-list-entry-keybinding {\n\tmargin-right: 8px; /* separate from the separator label or scrollbar if any */\n}\n\n.quick-input-list .quick-input-list-label-meta {\n\topacity: 0.7;\n\tline-height: normal;\n\ttext-overflow: ellipsis;\n\toverflow: hidden;\n}\n\n.quick-input-list .monaco-highlighted-label .highlight {\n\tfont-weight: bold;\n}\n\n.quick-input-list .quick-input-list-entry .quick-input-list-separator {\n\tmargin-right: 4px; /* separate from keybindings or actions */\n}\n\n.quick-input-list .quick-input-list-entry-action-bar {\n\tdisplay: flex;\n\tflex: 0;\n\toverflow: visible;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar .action-label {\n\t/*\n\t * By default, actions in the quick input action bar are hidden\n\t * until hovered over them or selected.\n\t */\n\tdisplay: none;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar .action-label.codicon {\n\tmargin-right: 4px;\n\tpadding: 0px 2px 2px 2px;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar {\n\tmargin-top: 1px;\n}\n\n.quick-input-list .quick-input-list-entry-action-bar {\n\tmargin-right: 4px; /* separate from scrollbar */\n}\n\n.quick-input-list .quick-input-list-entry .quick-input-list-entry-action-bar .action-label.always-visible,\n.quick-input-list .quick-input-list-entry:hover .quick-input-list-entry-action-bar .action-label,\n.quick-input-list .monaco-list-row.focused .quick-input-list-entry-action-bar .action-label {\n\tdisplay: flex;\n}\n\n/* focused items in quick pick */\n.quick-input-list .monaco-list-row.focused .monaco-keybinding-key,\n.quick-input-list .monaco-list-row.focused .quick-input-list-entry .quick-input-list-separator {\n\tcolor: inherit\n}\n.quick-input-list .monaco-list-row.focused .monaco-keybinding-key {\n\tbackground: none;\n}\n\n/* Quick input separators as full-row item */\n.quick-input-list .quick-input-list-separator-as-item {\n\tfont-weight: 600;\n\tfont-size: 12px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n/* ---------- Icon label ---------- */\n\n.monaco-icon-label {\n\tdisplay: flex; /* required for icons support :before rule */\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n}\n\n.monaco-icon-label::before {\n\n\t/* svg icons rendered as background image */\n\tbackground-size: 16px;\n\tbackground-position: left center;\n\tbackground-repeat: no-repeat;\n\tpadding-right: 6px;\n\twidth: 16px;\n\theight: 22px;\n\tline-height: inherit !important;\n\tdisplay: inline-block;\n\n\t/* fonts icons */\n\t-webkit-font-smoothing: antialiased;\n\t-moz-osx-font-smoothing: grayscale;\n\tvertical-align: top;\n\n\tflex-shrink: 0; /* fix for https://github.com/microsoft/vscode/issues/13787 */\n}\n\n.monaco-icon-label-container.disabled {\n\tcolor: var(--vscode-disabledForeground);\n}\n.monaco-icon-label > .monaco-icon-label-container {\n\tmin-width: 0;\n\toverflow: hidden;\n\ttext-overflow: ellipsis;\n\tflex: 1;\n}\n\n.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name {\n\tcolor: inherit;\n\twhite-space: pre; /* enable to show labels that include multiple whitespaces */\n}\n\n.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-name-container > .label-name > .label-separator {\n\tmargin: 0 2px;\n\topacity: 0.5;\n}\n\n.monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\topacity: .7;\n\tmargin-left: 0.5em;\n\tfont-size: 0.9em;\n\twhite-space: pre; /* enable to show labels that include multiple whitespaces */\n}\n\n.monaco-icon-label.nowrap > .monaco-icon-label-container > .monaco-icon-description-container > .label-description{\n\twhite-space: nowrap\n}\n\n.vs .monaco-icon-label > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\topacity: .95;\n}\n\n.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-name-container > .label-name,\n.monaco-icon-label.italic > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\tfont-style: italic;\n}\n\n.monaco-icon-label.deprecated {\n\ttext-decoration: line-through;\n\topacity: 0.66;\n}\n\n/* make sure apply italic font style to decorations as well */\n.monaco-icon-label.italic::after {\n\tfont-style: italic;\n}\n\n.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-name-container > .label-name,\n.monaco-icon-label.strikethrough > .monaco-icon-label-container > .monaco-icon-description-container > .label-description {\n\ttext-decoration: line-through;\n}\n\n.monaco-icon-label::after {\n\topacity: 0.75;\n\tfont-size: 90%;\n\tfont-weight: 600;\n\tmargin: auto 16px 0 5px; /* https://github.com/microsoft/vscode/issues/113223 */\n\ttext-align: center;\n}\n\n/* make sure selection color wins when a label is being selected */\n.monaco-list:focus .selected .monaco-icon-label, /* list */\n.monaco-list:focus .selected .monaco-icon-label::after\n{\n\tcolor: inherit !important;\n}\n\n.monaco-list-row.focused.selected .label-description,\n.monaco-list-row.selected .label-description {\n\topacity: .8;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-keybinding {\n\tdisplay: flex;\n\talign-items: center;\n\tline-height: 10px;\n}\n\n.monaco-keybinding > .monaco-keybinding-key {\n\tdisplay: inline-block;\n\tborder-style: solid;\n\tborder-width: 1px;\n\tborder-radius: 3px;\n\tvertical-align: middle;\n\tfont-size: 11px;\n\tpadding: 3px 5px;\n\tmargin: 0 2px;\n}\n\n.monaco-keybinding > .monaco-keybinding-key:first-child {\n\tmargin-left: 0;\n}\n\n.monaco-keybinding > .monaco-keybinding-key:last-child {\n\tmargin-right: 0;\n}\n\n.monaco-keybinding > .monaco-keybinding-key-separator {\n\tdisplay: inline-block;\n}\n\n.monaco-keybinding > .monaco-keybinding-key-chord-separator {\n\twidth: 6px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-editor .diff-hidden-lines-widget {\n\twidth: 100%;\n}\n\n.monaco-editor .diff-hidden-lines {\n\theight: 0px; /* The children each have a fixed height, the transform confuses the browser */\n\ttransform: translate(0px, -10px);\n\tfont-size: 13px;\n\tline-height: 14px;\n}\n\n.monaco-editor .diff-hidden-lines:not(.dragging) .top:hover,\n.monaco-editor .diff-hidden-lines:not(.dragging) .bottom:hover,\n.monaco-editor .diff-hidden-lines .top.dragging,\n.monaco-editor .diff-hidden-lines .bottom.dragging {\n\tbackground-color: var(--vscode-focusBorder);\n}\n\n.monaco-editor .diff-hidden-lines .top,\n.monaco-editor .diff-hidden-lines .bottom {\n\ttransition: background-color 0.1s ease-out;\n\theight: 4px;\n\tbackground-color: transparent;\n\tbackground-clip: padding-box;\n\tborder-bottom: 2px solid transparent;\n\tborder-top: 4px solid transparent;\n\tcursor: ns-resize;\n}\n\n.monaco-editor .diff-hidden-lines .top {\n\ttransform: translate(0px, 4px);\n}\n\n.monaco-editor .diff-hidden-lines .bottom {\n\ttransform: translate(0px, -6px);\n}\n\n.monaco-editor .diff-unchanged-lines {\n\tbackground: var(--vscode-diffEditor-unchangedCodeBackground);\n}\n\n.monaco-editor .noModificationsOverlay {\n\tz-index: 1;\n\tbackground: var(--vscode-editor-background);\n\n\tdisplay: flex;\n\tjustify-content: center;\n\talign-items: center;\n}\n\n\n.monaco-editor .diff-hidden-lines .center {\n\tbackground: var(--vscode-diffEditor-unchangedRegionBackground);\n\tcolor: var(--vscode-diffEditor-unchangedRegionForeground);\n\toverflow: hidden;\n\tdisplay: block;\n\ttext-overflow: ellipsis;\n\twhite-space: nowrap;\n\n\theight: 24px;\n}\n\n.monaco-editor .diff-hidden-lines .center span.codicon {\n\tvertical-align: middle;\n}\n\n.monaco-editor .diff-hidden-lines .center a:hover .codicon {\n\tcursor: pointer;\n\tcolor: var(--vscode-editorLink-activeForeground) !important;\n}\n\n.monaco-editor .diff-hidden-lines div.breadcrumb-item {\n\tcursor: pointer;\n}\n\n.monaco-editor .diff-hidden-lines div.breadcrumb-item:hover {\n\tcolor: var(--vscode-editorLink-activeForeground);\n}\n\n.monaco-editor .movedOriginal {\n\tborder: 2px solid var(--vscode-diffEditor-move-border);\n}\n\n.monaco-editor .movedModified {\n\tborder: 2px solid var(--vscode-diffEditor-move-border);\n}\n\n.monaco-editor .movedOriginal.currentMove, .monaco-editor .movedModified.currentMove {\n\tborder: 2px solid var(--vscode-diffEditor-moveActive-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines path.currentMove {\n\tstroke: var(--vscode-diffEditor-moveActive-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines path {\n\tpointer-events: visiblestroke;\n}\n\n.monaco-diff-editor .moved-blocks-lines .arrow {\n\tfill: var(--vscode-diffEditor-move-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines .arrow.currentMove {\n\tfill: var(--vscode-diffEditor-moveActive-border);\n}\n\n.monaco-diff-editor .moved-blocks-lines .arrow-rectangle {\n\tfill: var(--vscode-editor-background);\n}\n\n.monaco-diff-editor .moved-blocks-lines {\n\tposition: absolute;\n\tpointer-events: none;\n}\n\n.monaco-diff-editor .moved-blocks-lines path {\n\tfill: none;\n\tstroke: var(--vscode-diffEditor-move-border);\n\tstroke-width: 2;\n}\n\n.monaco-editor .char-delete.diff-range-empty {\n\tmargin-left: -1px;\n\tborder-left: solid var(--vscode-diffEditor-removedTextBackground) 3px;\n}\n\n.monaco-editor .char-insert.diff-range-empty {\n\tborder-left: solid var(--vscode-diffEditor-insertedTextBackground) 3px;\n}\n\n.monaco-editor .fold-unchanged {\n\tcursor: pointer;\n}\n\n.monaco-diff-editor .diff-moved-code-block {\n\tdisplay: flex;\n\tjustify-content: flex-end;\n\tmargin-top: -4px;\n}\n\n.monaco-diff-editor .diff-moved-code-block .action-bar .action-label.codicon {\n\twidth: 12px;\n\theight: 12px;\n\tfont-size: 12px;\n}\n\n/* ---------- DiffEditor ---------- */\n\n.monaco-diff-editor .diffOverview {\n\tz-index: 9;\n}\n\n.monaco-diff-editor .diffOverview .diffViewport {\n\tz-index: 10;\n}\n\n/* colors not externalized: using transparancy on background */\n.monaco-diff-editor.vs\t\t\t.diffOverview { background: rgba(0, 0, 0, 0.03); }\n.monaco-diff-editor.vs-dark\t\t.diffOverview { background: rgba(255, 255, 255, 0.01); }\n\n.monaco-scrollable-element.modified-in-monaco-diff-editor.vs\t\t.scrollbar { background: rgba(0,0,0,0); }\n.monaco-scrollable-element.modified-in-monaco-diff-editor.vs-dark\t.scrollbar { background: rgba(0,0,0,0); }\n.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-black\t.scrollbar { background: none; }\n.monaco-scrollable-element.modified-in-monaco-diff-editor.hc-light\t.scrollbar { background: none; }\n\n.monaco-scrollable-element.modified-in-monaco-diff-editor .slider {\n\tz-index: 10;\n}\n.modified-in-monaco-diff-editor\t\t\t\t.slider.active { background: rgba(171, 171, 171, .4); }\n.modified-in-monaco-diff-editor.hc-black\t.slider.active { background: none; }\n.modified-in-monaco-diff-editor.hc-light\t.slider.active { background: none; }\n\n/* ---------- Diff ---------- */\n\n.monaco-editor .insert-sign,\n.monaco-diff-editor .insert-sign,\n.monaco-editor .delete-sign,\n.monaco-diff-editor .delete-sign {\n\tfont-size: 11px !important;\n\topacity: 0.7 !important;\n\tdisplay: flex !important;\n\talign-items: center;\n}\n.monaco-editor.hc-black .insert-sign,\n.monaco-diff-editor.hc-black .insert-sign,\n.monaco-editor.hc-black .delete-sign,\n.monaco-diff-editor.hc-black .delete-sign,\n.monaco-editor.hc-light .insert-sign,\n.monaco-diff-editor.hc-light .insert-sign,\n.monaco-editor.hc-light .delete-sign,\n.monaco-diff-editor.hc-light .delete-sign {\n\topacity: 1;\n}\n\n.monaco-editor .inline-deleted-margin-view-zone {\n\ttext-align: right;\n}\n.monaco-editor .inline-added-margin-view-zone {\n\ttext-align: right;\n}\n\n.monaco-editor .arrow-revert-change {\n\tz-index: 10;\n\tposition: absolute;\n}\n\n.monaco-editor .arrow-revert-change:hover {\n\tcursor: pointer;\n}\n\n/* ---------- Inline Diff ---------- */\n\n.monaco-editor .view-zones .view-lines .view-line span {\n\tdisplay: inline-block;\n}\n\n.monaco-editor .margin-view-zones .lightbulb-glyph:hover {\n\tcursor: pointer;\n}\n\n.monaco-editor .char-insert, .monaco-diff-editor .char-insert {\n\tbackground-color: var(--vscode-diffEditor-insertedTextBackground);\n}\n\n.monaco-editor .line-insert, .monaco-diff-editor .line-insert {\n\tbackground-color: var(--vscode-diffEditor-insertedLineBackground, var(--vscode-diffEditor-insertedTextBackground));\n}\n\n.monaco-editor .line-insert,\n.monaco-editor .char-insert {\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-diffEditor-insertedTextBorder);\n}\n.monaco-editor.hc-black .line-insert, .monaco-editor.hc-light .line-insert,\n.monaco-editor.hc-black .char-insert, .monaco-editor.hc-light .char-insert {\n\tborder-style: dashed;\n}\n\n.monaco-editor .line-delete,\n.monaco-editor .char-delete {\n\tbox-sizing: border-box;\n\tborder: 1px solid var(--vscode-diffEditor-removedTextBorder);\n}\n.monaco-editor.hc-black .line-delete, .monaco-editor.hc-light .line-delete,\n.monaco-editor.hc-black .char-delete, .monaco-editor.hc-light .char-delete {\n\tborder-style: dashed;\n}\n\n.monaco-editor .inline-added-margin-view-zone,\n.monaco-editor .gutter-insert, .monaco-diff-editor .gutter-insert {\n\tbackground-color: var(--vscode-diffEditorGutter-insertedLineBackground, var(--vscode-diffEditor-insertedLineBackground), var(--vscode-diffEditor-insertedTextBackground));\n}\n\n.monaco-editor .char-delete, .monaco-diff-editor .char-delete {\n\tbackground-color: var(--vscode-diffEditor-removedTextBackground);\n}\n\n.monaco-editor .line-delete, .monaco-diff-editor .line-delete {\n\tbackground-color: var(--vscode-diffEditor-removedLineBackground, var(--vscode-diffEditor-removedTextBackground));\n}\n\n.monaco-editor .inline-deleted-margin-view-zone,\n.monaco-editor .gutter-delete, .monaco-diff-editor .gutter-delete {\n\tbackground-color: var(--vscode-diffEditorGutter-removedLineBackground, var(--vscode-diffEditor-removedLineBackground), var(--vscode-diffEditor-removedTextBackground));\n}\n\n.monaco-diff-editor.side-by-side .editor.modified {\n\tbox-shadow: -6px 0 5px -5px var(--vscode-scrollbar-shadow);\n\tborder-left: 1px solid var(--vscode-diffEditor-border);\n}\n\n.monaco-diff-editor .diffViewport {\n\tbackground: var(--vscode-scrollbarSlider-background);\n}\n\n.monaco-diff-editor .diffViewport:hover {\n\tbackground: var(--vscode-scrollbarSlider-hoverBackground);\n}\n\n.monaco-diff-editor .diffViewport:active {\n\tbackground: var(--vscode-scrollbarSlider-activeBackground);\n}\n\n.monaco-editor .diagonal-fill {\n\tbackground-image: linear-gradient(\n\t\t-45deg,\n\t\tvar(--vscode-diffEditor-diagonalFill) 12.5%,\n\t\t#0000 12.5%, #0000 50%,\n\t\tvar(--vscode-diffEditor-diagonalFill) 50%, var(--vscode-diffEditor-diagonalFill) 62.5%,\n\t\t#0000 62.5%, #0000 100%\n\t);\n\tbackground-size: 8px 8px;\n}\n", "/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n\n.monaco-diff-editor .diff-review-line-number {\n\ttext-align: right;\n\tdisplay: inline-block;\n\tcolor: var(--vscode-editorLineNumber-foreground);\n}\n\n.monaco-diff-editor .diff-review {\n\tposition: absolute;\n\tuser-select: none;\n\t-webkit-user-select: none;\n\tz-index: 99;\n}\n\n.monaco-diff-editor .diff-review-summary {\n\tpadding-left: 10px;\n}\n\n.monaco-diff-editor .diff-review-shadow {\n\tposition: absolute;\n\tbox-shadow: var(--vscode-scrollbar-shadow) 0 -6px 6px -6px inset;\n}\n\n.monaco-diff-editor .diff-review-row {\n\twhite-space: pre;\n}\n\n.monaco-diff-editor .diff-review-table {\n\tdisplay: table;\n\tmin-width: 100%;\n}\n\n.monaco-diff-editor .diff-review-row {\n\tdisplay: table-row;\n\twidth: 100%;\n}\n\n.monaco-diff-editor .diff-review-spacer {\n\tdisplay: inline-block;\n\twidth: 10px;\n\tvertical-align: middle;\n}\n\n.monaco-diff-editor .diff-review-spacer > .codicon {\n\tfont-size: 9px !important;\n}\n\n.monaco-diff-editor .diff-review-actions {\n\tdisplay: inline-block;\n\tposition: absolute;\n\tright: 10px;\n\ttop: 2px;\n\tz-index: 100;\n}\n\n.monaco-diff-editor .diff-review-actions .action-label {\n\twidth: 16px;\n\theight: 16px;\n\tmargin: 2px 0;\n}\n"],
  "mappings": ";AAAA;AACE;AAAA;;;ACMF;AACC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAAA;AAGC;AAAA;AAGD;AACC;AAAA;AAID;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;;;AC/BD;AACC;AACA;AAAA;;;ACAD;AACC;AAAA;AAKD;AACC;AAAA;AAKD;AACC;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AAAA;AAED;AACC;AACA;AACA;AAAA;AAED;AAAA;AACC;AAAA;AAED;AACC;AACA;AACA;AAAA;AAED;AAAA;AACC;AAAA;AAKD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAUD;AACC;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AAAA;AAED;AACC;AAAA;AAED;AACC;AACA;AAAA;;;ACjGD;AACC;AACA;AAAA;AAGD;AACC;AAGA;AAEA;AAEA;AAAA;AAED;AACC;AACA;AAAA;AAED;AACC;AAAA;AAID;AACC;AACA;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;ACjED;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAgBD;AACC;AACA;AACA;AAAA;;;AC/BD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;AC1BD;AACC;AAAA;;;ACDD;AACC;AAAA;;;ACDD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;;;ACbD;AACC;AAAA;;;ACLD;AACC;AACA;AAAA;;;ACSD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAED;AACC;AAAA;AAGD;AAAA;AAAA;AAGC;AACA;AAAA;AAID;AAAA;AAAA;AAGC;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;;;ACnED;AACC;AACA;AACA;AAAA;AAOD;AACC;AACA;AAAA;;;ACXD;AACC;AACA;AAAA;AAOD;AACC;AACA;AACA;AACA;AAAA;AAQD;AACC;AACA;AACA;AACA;AAAA;;;ACrBD;AACC;AACA;AACA;AACA;AAAA;;;ACPD;AACC;AACA;AAAA;AAED;AACC;AAAA;AAED;AACC;AAAA;AAGD;AACC;AAAA;AAED;AACC;AAAA;AAED;AACC;AAAA;AAED;AACC;AAAA;AAED;AACC;AACA;AAAA;AAED;AACC;AACA;AACA;AAAA;AAED;AACC;AACA;AACA;AAAA;AAID;AACC;AACA;AAAA;AAED;AACC;AAAA;AAGD;AACC;AAAA;;;AClDD;AACC;AACA;AACA;AAAA;;;ACFD;AACC;AACA;AACA;AAAA;;;ACHD;AACC;AACA;AACA;AACA;AACA;AAAA;;;ACDD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAqC;AAAA;AACrC;AAAwC;AAAA;AACxC;AAAsC;AAAA;AACtC;AAAwC;AAAA;AAExC;AAA4C;AAAA;AAC5C;AAA+C;AAAA;AAC/C;AAA6C;AAAA;AAC7C;AAA+C;AAAA;AAE/C;AAA4C;AAAA;AAC5C;AAA+C;AAAA;AAC/C;AAA6C;AAAA;AAC7C;AAA+C;AAAA;;;AC9B/C;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAID;AACC;AAAA;AAID;AACC;AACA;AACA;AAAA;AAID;AACC;AACA;AACA;AAAA;AAID;AACC;AACA;AACA;AAAA;AAGD;AAAA;AAGE;AAAA;AAAA;AAIA;AAAA;AAAA;AAIF;AAAA;AAGE;AAAA;AAAA;AAIA;AAAA;AAAA;AAIF;AAAA;AAGE;AAAA;AAAA;AAIA;AAAA;AAAA;AAIF;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;AC9ED;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;;;ACRD;AACC;AACA;AAAA;;;ACFD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;;;ACTD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAID;AACC;AAAA;AAID;AAAA;AAAA;AAGC;AAAA;AAID;AACC;AACA;AACA;AACA;AACA;AACA;AAAA;AAKD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;;;AC7ED;AACC;AACA;AAAA;AAGD;AAAA;AAEC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAID;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAOD;AACE;AACA;AACA;AACA;AACA;AACA;AAAA;AAGF;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;;;ACvHD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAKD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;;;AC3BD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AAAA;AAAA;AAGC;AAAA;AAKD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAID;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;;;AC9GD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;;;ACvCD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;;;ACtCD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;;;ACxDD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AAAA;AAIC;AAAA;AAGD;AAAA;AAIC;AAAA;AAGD;AACC;AACA;AAAA;AAED;AACC;AACA;AAAA;AAED;AACC;AACA;AAAA;AAED;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAKD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;AC9ID;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;;;AC/DD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AAAA;AAEC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AAAA;AAEC;AAAA;;;AClDD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAID;AACC;AAAA;;;AChDD;AACC;AACA;AACA;AACA;AACA;AAGA;AAAA;AAGD;AAAA;AAIC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAKD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAID;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;;;ACnGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAID;AACC;AAAA;AAID;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AACM;AAAA;AAAA;AACE;AAAA;AAAA;AAER;AAAA;AACM;AAAA;AAAA;AAEC;AAAA;AAAA;AAGP;AAAA;AACM;AAAA;AAAA;AACE;AAAA;AAAA;AAER;AAAA;AACM;AAAA;AAAA;AAEC;AAAA;AAAA;;;AC/DP;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAED;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAEC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;AC3HD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AAAA;AAEC;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAAA;AAGC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AAAA;AAEC;AACA;AACA;AAAA;AAGD;AAAA;AAEC;AACA;AAAA;AAKD;AAAA;AAEC;AACA;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AACA;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;ACrKD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;;;ACjBD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AAOC;AAAA;AAaD;AAAA;AAA6B;AAAA;AAAA;AAA4C;AAAA;AAAA;AAA8C;AAAA;AAAA;;;ACvDvH;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AAEC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAID;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAED;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AAKC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAAA;AAGC;AAAA;AAID;AAAA;AAEC;AAAA;AAED;AACC;AAAA;AAID;AACC;AACA;AAAA;;;AC7TD;AACC;AACA;AACA;AAAA;AAGD;AAGC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AAEA;AAAA;AAGD;AACC;AAAA;AAED;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AAAA;AAID;AACC;AAAA;AAGD;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAID;AAAA;AAGC;AAAA;AAGD;AAAA;AAEC;AAAA;;;ACpGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;;;AC9BD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AAAA;AAAA;AAAA;AAIC;AAAA;AAGD;AAAA;AAEC;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAEA;AACA;AACA;AAAA;AAID;AACC;AACA;AACA;AACA;AACA;AACA;AAEA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAKD;AACC;AAAA;AAGD;AACC;AAAA;AAID;AAAyC;AAAA;AACzC;AAA6C;AAAA;AAE7C;AAA2E;AAAA;AAC3E;AAA+E;AAAA;AAC/E;AAAgF;AAAA;AAChF;AAAgF;AAAA;AAEhF;AACC;AAAA;AAED;AAAoD;AAAA;AACpD;AAA0D;AAAA;AAC1D;AAA0D;AAAA;AAI1D;AAAA;AAAA;AAAA;AAIC;AACA;AACA;AACA;AAAA;AAED;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQC;AAAA;AAGD;AACC;AAAA;AAED;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAKD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AAAA;AACC;AAAA;AAGD;AAAA;AACC;AAAA;AAGD;AAAA;AAEC;AACA;AAAA;AAED;AAAA;AAAA;AAAA;AAEC;AAAA;AAGD;AAAA;AAEC;AACA;AAAA;AAED;AAAA;AAAA;AAAA;AAEC;AAAA;AAGD;AAAA;AAAA;AAEC;AAAA;AAGD;AAAA;AACC;AAAA;AAGD;AAAA;AACC;AAAA;AAGD;AAAA;AAAA;AAEC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AAOA;AAAA;;;ACpSD;AACC;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;AAGD;AACC;AAAA;AAGD;AACC;AACA;AACA;AACA;AACA;AAAA;AAGD;AACC;AACA;AACA;AAAA;",
  "names": []
}
 */ diff --git a/manifest.json b/manifest.json index dfa940e..7ff292c 100644 --- a/manifest.json +++ b/manifest.json @@ -1,11 +1,11 @@ { - "id": "sample-plugin", - "name": "Sample Plugin", + "id": "code-editor", + "name": "Code Editor", "version": "1.0.0", "minAppVersion": "0.15.0", "description": "Demonstrates some of the capabilities of the Obsidian API.", - "author": "Obsidian", - "authorUrl": "https://obsidian.md", - "fundingUrl": "https://obsidian.md/pricing", + "author": "Allen7D", + "authorUrl": "https://github.com/Allen7D", + "fundingUrl": "https://github.com/Allen7D/obsidian-code-editor", "isDesktopOnly": false -} +} \ No newline at end of file diff --git a/package.json b/package.json index 6a00766..360caa7 100644 --- a/package.json +++ b/package.json @@ -1,5 +1,5 @@ { - "name": "obsidian-sample-plugin", + "name": "obsidian-code-editor", "version": "1.0.0", "description": "This is a sample plugin for Obsidian (https://obsidian.md)", "main": "main.js", @@ -13,12 +13,22 @@ "license": "MIT", "devDependencies": { "@types/node": "^16.11.6", + "@types/react": "^18.2.69", + "@types/react-dom": "^18.2.22", "@typescript-eslint/eslint-plugin": "5.29.0", "@typescript-eslint/parser": "5.29.0", "builtin-modules": "3.3.0", "esbuild": "0.17.3", + "esbuild-plugin-less": "^1.3.3", + "less": "^4.2.0", "obsidian": "latest", + "react": "^18.2.0", + "react-dom": "^18.2.0", "tslib": "2.4.0", "typescript": "4.7.4" + }, + "dependencies": { + "monaco-editor": "^0.44.0", + "react-monaco-editor": "^0.55.0" } -} +} \ No newline at end of file diff --git a/src/SettingTab.ts b/src/SettingTab.ts new file mode 100644 index 0000000..9300738 --- /dev/null +++ b/src/SettingTab.ts @@ -0,0 +1,31 @@ +import { App, PluginSettingTab, Setting } from 'obsidian'; +import ExamplePlugin from './main'; + +// 属性设置页 +export class SettingTab extends PluginSettingTab { + plugin: ExamplePlugin; + + constructor(app: App, plugin: ExamplePlugin) { + super(app, plugin); + this.plugin = plugin; + } + + display(): void { + const { containerEl } = this; + + containerEl.empty(); + + new Setting(containerEl) + .setName('Setting #1') + .setDesc("It's a secret") + .addText((text) => + text + .setPlaceholder('Enter your secret') + .setValue(this.plugin.settings.mySetting) + .onChange(async (value) => { + this.plugin.settings.mySetting = value; + await this.plugin.saveSettings(); + }), + ); + } +} diff --git a/src/components/App/index.less b/src/components/App/index.less new file mode 100644 index 0000000..f26861a --- /dev/null +++ b/src/components/App/index.less @@ -0,0 +1,3 @@ +.app-main { + color: red; +} \ No newline at end of file diff --git a/src/components/App/index.tsx b/src/components/App/index.tsx new file mode 100644 index 0000000..c450cdb --- /dev/null +++ b/src/components/App/index.tsx @@ -0,0 +1,13 @@ +import React from 'react'; + +import './index.less'; + +const App: React.FC = () => { + return ( +